tests/test_export.py

"""Tests for the ML export pipeline."""

import pytest

from negbiodb.db import connect, create_database, refresh_all_pairs
import pandas as pd
import numpy as np

from negbiodb.export import (
    _compute_scaffolds,
    _register_split,
    add_cold_compound_split,
    add_cold_target_split,
    add_random_split,
    apply_m1_splits,
    export_negative_dataset,
    generate_cold_compound_split,
    generate_cold_target_split,
    generate_degree_balanced_split,
    generate_degree_matched_negatives,
    generate_leakage_report,
    generate_random_split,
    generate_scaffold_split,
    generate_temporal_split,
    generate_uniform_random_negatives,
    merge_positive_negative,
)

MIGRATIONS_DIR = "migrations"


@pytest.fixture
def migrated_db(tmp_path):
    db_path = tmp_path / "test.db"
    create_database(db_path, MIGRATIONS_DIR)
    return db_path


def _populate_small_db(conn, n_compounds=10, n_targets=5):
    """Insert n_compounds * n_targets pairs for testing splits."""
    for i in range(1, n_compounds + 1):
        conn.execute(
            """INSERT INTO compounds
            (canonical_smiles, inchikey, inchikey_connectivity)
            VALUES (?, ?, ?)""",
            (f"C{i}", f"KEY{i:011d}SA-N", f"KEY{i:011d}"),
        )
    for j in range(1, n_targets + 1):
        conn.execute(
            "INSERT INTO targets (uniprot_accession) VALUES (?)",
            (f"P{j:05d}",),
        )
    for i in range(1, n_compounds + 1):
        for j in range(1, n_targets + 1):
            conn.execute(
                """INSERT INTO negative_results
                (compound_id, target_id, result_type, confidence_tier,
                 activity_type, activity_value, activity_unit,
                 inactivity_threshold, source_db, source_record_id,
                 extraction_method, publication_year)
                VALUES (?, ?, 'hard_negative', 'silver',
                        'IC50', 20000.0, 'nM',
                        10000.0, 'chembl', ?, 'database_direct', ?)""",
                (i, j, f"C:{i}:{j}", 2015 + (i % 10)),
            )
    refresh_all_pairs(conn)
    conn.commit()
    return n_compounds * n_targets


def _populate_partial_db(conn, n_compounds=20, n_targets=10, pairs_per_compound=3):
    """Insert compounds and targets with partial pairing.

    Each compound is paired with only ``pairs_per_compound`` targets
    (rotating window), leaving most of the compound×target space
    untested.  Needed for testing random negative generation where
    untested pairs must exist within the DB compound space.
    """
    for i in range(1, n_compounds + 1):
        conn.execute(
            """INSERT INTO compounds
            (canonical_smiles, inchikey, inchikey_connectivity)
            VALUES (?, ?, ?)""",
            (f"C{i}", f"KEY{i:011d}SA-N", f"KEY{i:011d}"),
        )
    for j in range(1, n_targets + 1):
        conn.execute(
            "INSERT INTO targets (uniprot_accession) VALUES (?)",
            (f"P{j:05d}",),
        )
    count = 0
    for i in range(1, n_compounds + 1):
        for k in range(pairs_per_compound):
            j = ((i - 1 + k) % n_targets) + 1
            conn.execute(
                """INSERT INTO negative_results
                (compound_id, target_id, result_type, confidence_tier,
                 activity_type, activity_value, activity_unit,
                 inactivity_threshold, source_db, source_record_id,
                 extraction_method, publication_year)
                VALUES (?, ?, 'hard_negative', 'silver',
                        'IC50', 20000.0, 'nM',
                        10000.0, 'chembl', ?, 'database_direct', ?)""",
                (i, j, f"C:{i}:{j}", 2015 + (i % 10)),
            )
            count += 1
    refresh_all_pairs(conn)
    conn.commit()
    return count


# ============================================================
# TestRegisterSplit
# ============================================================


class TestRegisterSplit:

    def test_creates_definition(self, migrated_db):
        with connect(migrated_db) as conn:
            sid = _register_split(
                conn, "test_split", "random", 42,
                {"train": 0.7, "val": 0.1, "test": 0.2},
            )
            row = conn.execute(
                "SELECT split_name, split_strategy, random_seed "
                "FROM split_definitions WHERE split_id = ?",
                (sid,),
            ).fetchone()
            assert row == ("test_split", "random", 42)

    def test_idempotent(self, migrated_db):
        with connect(migrated_db) as conn:
            sid1 = _register_split(
                conn, "test_split", "random", 42,
                {"train": 0.7, "val": 0.1, "test": 0.2},
            )
            sid2 = _register_split(
                conn, "test_split", "random", 42,
                {"train": 0.7, "val": 0.1, "test": 0.2},
            )
            assert sid1 == sid2


# ============================================================
# TestRandomSplit
# ============================================================


class TestRandomSplit:

    def test_ratios_within_tolerance(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 20, 10)
            result = generate_random_split(conn)
            counts = result["counts"]
            assert abs(counts["train"] / total - 0.7) < 0.05
            assert abs(counts["val"] / total - 0.1) < 0.05
            assert abs(counts["test"] / total - 0.2) < 0.05
            assert counts["train"] + counts["val"] + counts["test"] == total

    def test_deterministic(self, migrated_db):
        """Same seed should produce identical assignments."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)
            r1 = generate_random_split(conn, seed=42)

        # Fresh DB with same data
        db2 = migrated_db.parent / "test2.db"
        create_database(db2, MIGRATIONS_DIR)
        with connect(db2) as conn:
            _populate_small_db(conn, 10, 5)
            r2 = generate_random_split(conn, seed=42)

        assert r1["counts"] == r2["counts"]

    def test_all_pairs_assigned(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 10, 5)
            result = generate_random_split(conn)
            assigned = conn.execute(
                "SELECT COUNT(*) FROM split_assignments WHERE split_id = ?",
                (result["split_id"],),
            ).fetchone()[0]
            assert assigned == total


# ============================================================
# TestColdCompoundSplit
# ============================================================


class TestColdCompoundSplit:

    def test_no_compound_leakage(self, migrated_db):
        """No compound should appear in both train and test."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 20, 5)
            result = generate_cold_compound_split(conn)
            sid = result["split_id"]

            leaks = conn.execute(
                """SELECT COUNT(DISTINCT ctp1.compound_id)
                FROM split_assignments sa1
                JOIN compound_target_pairs ctp1 ON sa1.pair_id = ctp1.pair_id
                WHERE sa1.split_id = ? AND sa1.fold = 'train'
                AND ctp1.compound_id IN (
                    SELECT ctp2.compound_id
                    FROM split_assignments sa2
                    JOIN compound_target_pairs ctp2 ON sa2.pair_id = ctp2.pair_id
                    WHERE sa2.split_id = ? AND sa2.fold = 'test'
                )""",
                (sid, sid),
            ).fetchone()[0]
            assert leaks == 0

    def test_all_pairs_assigned(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 10, 5)
            result = generate_cold_compound_split(conn)
            assigned = sum(result["counts"].values())
            assert assigned == total

    def test_compound_ratios(self, migrated_db):
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 20, 5)
            result = generate_cold_compound_split(conn)
            sid = result["split_id"]
            # Count unique compounds per fold
            for fold in ("train", "val", "test"):
                conn.execute(
                    """SELECT COUNT(DISTINCT ctp.compound_id)
                    FROM split_assignments sa
                    JOIN compound_target_pairs ctp ON sa.pair_id = ctp.pair_id
                    WHERE sa.split_id = ? AND sa.fold = ?""",
                    (sid, fold),
                ).fetchone()[0]
            # Just verify it ran without error and all 3 folds exist
            assert set(result["counts"].keys()) == {"train", "val", "test"}


# ============================================================
# TestColdTargetSplit
# ============================================================


class TestColdTargetSplit:

    def test_no_target_leakage(self, migrated_db):
        """No target should appear in both train and test."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 10)
            result = generate_cold_target_split(conn)
            sid = result["split_id"]

            leaks = conn.execute(
                """SELECT COUNT(DISTINCT ctp1.target_id)
                FROM split_assignments sa1
                JOIN compound_target_pairs ctp1 ON sa1.pair_id = ctp1.pair_id
                WHERE sa1.split_id = ? AND sa1.fold = 'train'
                AND ctp1.target_id IN (
                    SELECT ctp2.target_id
                    FROM split_assignments sa2
                    JOIN compound_target_pairs ctp2 ON sa2.pair_id = ctp2.pair_id
                    WHERE sa2.split_id = ? AND sa2.fold = 'test'
                )""",
                (sid, sid),
            ).fetchone()[0]
            assert leaks == 0

    def test_all_pairs_assigned(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 10, 10)
            result = generate_cold_target_split(conn)
            assigned = sum(result["counts"].values())
            assert assigned == total


# ============================================================
# TestTemporalSplit
# ============================================================

# Valid SMILES for scaffold tests (diverse scaffolds)
REAL_SMILES = [
    "c1ccc(NC(=O)c2ccccc2)cc1",       # benzanilide
    "c1ccc2[nH]ccc2c1",                # indole
    "c1ccc(-c2ccccn2)cc1",             # 2-phenylpyridine
    "O=C1CCCN1",                        # pyrrolidinone
    "c1ccc2ccccc2c1",                   # naphthalene
    "c1cnc2ccccc2n1",                   # quinazoline
    "c1ccc(-c2ccc3ccccc3c2)cc1",       # 2-phenylnaphthalene
    "O=c1[nH]c2ccccc2o1",              # benzoxazolone
    "c1ccc2[nH]c(-c3ccccc3)nc2c1",     # 2-phenylbenzimidazole
    "c1ccc2c(c1)ccc1ccccc12",          # fluorene
]


def _populate_with_real_smiles(conn, n_targets=3, years=None):
    """Insert compounds with valid SMILES + targets + results.

    Returns total pair count.
    """
    n_compounds = len(REAL_SMILES)
    if years is None:
        years = list(range(2015, 2015 + n_compounds))

    for i, smi in enumerate(REAL_SMILES, 1):
        conn.execute(
            """INSERT INTO compounds
            (canonical_smiles, inchikey, inchikey_connectivity)
            VALUES (?, ?, ?)""",
            (smi, f"REAL{i:011d}SA-N", f"REAL{i:011d}"),
        )
    for j in range(1, n_targets + 1):
        conn.execute(
            "INSERT INTO targets (uniprot_accession) VALUES (?)",
            (f"Q{j:05d}",),
        )
    for i in range(1, n_compounds + 1):
        yr = years[i - 1] if i - 1 < len(years) else 2020
        for j in range(1, n_targets + 1):
            conn.execute(
                """INSERT INTO negative_results
                (compound_id, target_id, result_type, confidence_tier,
                 activity_type, activity_value, activity_unit,
                 inactivity_threshold, source_db, source_record_id,
                 extraction_method, publication_year)
                VALUES (?, ?, 'hard_negative', 'silver',
                        'IC50', 20000.0, 'nM',
                        10000.0, 'chembl', ?, 'database_direct', ?)""",
                (i, j, f"R:{i}:{j}", yr),
            )
    refresh_all_pairs(conn)
    conn.commit()
    return n_compounds * n_targets


class TestTemporalSplit:

    def test_correct_fold_assignment(self, migrated_db):
        """Pairs assigned based on earliest_year boundaries."""
        with connect(migrated_db) as conn:
            # 10 compounds × 3 targets, years 2015-2024
            _populate_with_real_smiles(conn, n_targets=3)
            result = generate_temporal_split(conn, train_cutoff=2020, val_cutoff=2023)
            counts = result["counts"]
            # years 2015-2019 → train (5 compounds × 3 = 15)
            # years 2020-2022 → val (3 compounds × 3 = 9)
            # years 2023-2024 → test (2 compounds × 3 = 6)
            assert counts["train"] == 15
            assert counts["val"] == 9
            assert counts["test"] == 6

    def test_null_year_goes_to_train(self, migrated_db):
        """Pairs with NULL earliest_year are assigned to train."""
        with connect(migrated_db) as conn:
            # Insert one compound with no publication_year
            conn.execute(
                """INSERT INTO compounds
                (canonical_smiles, inchikey, inchikey_connectivity)
                VALUES ('C', 'NULLYR00000000000SA-N', 'NULLYR00000000000')"""
            )
            conn.execute(
                "INSERT INTO targets (uniprot_accession) VALUES ('P99999')"
            )
            conn.execute(
                """INSERT INTO negative_results
                (compound_id, target_id, result_type, confidence_tier,
                 activity_type, activity_value, activity_unit,
                 inactivity_threshold, source_db, source_record_id,
                 extraction_method)
                VALUES (1, 1, 'hard_negative', 'silver',
                        'IC50', 20000.0, 'nM',
                        10000.0, 'chembl', 'N:1:1', 'database_direct')"""
            )
            refresh_all_pairs(conn)
            conn.commit()

            result = generate_temporal_split(conn)
            sid = result["split_id"]
            fold = conn.execute(
                "SELECT fold FROM split_assignments WHERE split_id = ?",
                (sid,),
            ).fetchone()[0]
            assert fold == "train"

    def test_all_pairs_assigned(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 10, 5)
            result = generate_temporal_split(conn)
            assigned = sum(result["counts"].values())
            assert assigned == total


# ============================================================
# TestScaffoldSplit
# ============================================================


class TestScaffoldSplit:

    def test_no_compound_leakage(self, migrated_db):
        """No compound should appear in both train and test."""
        with connect(migrated_db) as conn:
            _populate_with_real_smiles(conn, n_targets=5)
            result = generate_scaffold_split(conn)
            sid = result["split_id"]

            leaks = conn.execute(
                """SELECT COUNT(DISTINCT ctp1.compound_id)
                FROM split_assignments sa1
                JOIN compound_target_pairs ctp1 ON sa1.pair_id = ctp1.pair_id
                WHERE sa1.split_id = ? AND sa1.fold = 'train'
                AND ctp1.compound_id IN (
                    SELECT ctp2.compound_id
                    FROM split_assignments sa2
                    JOIN compound_target_pairs ctp2 ON sa2.pair_id = ctp2.pair_id
                    WHERE sa2.split_id = ? AND sa2.fold = 'test'
                )""",
                (sid, sid),
            ).fetchone()[0]
            assert leaks == 0

    def test_all_pairs_assigned(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_with_real_smiles(conn, n_targets=5)
            result = generate_scaffold_split(conn)
            assigned = sum(result["counts"].values())
            assert assigned == total

    def test_scaffold_computation(self, migrated_db):
        """Verify scaffolds are computed for real SMILES."""
        with connect(migrated_db) as conn:
            _populate_with_real_smiles(conn, n_targets=1)
            scaffolds = _compute_scaffolds(conn)
            # All 10 real SMILES should produce valid scaffolds (not NONE)
            all_compounds = []
            for compounds in scaffolds.values():
                all_compounds.extend(compounds)
            assert len(all_compounds) == 10
            # "NONE" scaffold should not exist for valid SMILES
            assert "NONE" not in scaffolds

    def test_invalid_smiles_get_none_scaffold(self, migrated_db):
        """Compounds with unparseable SMILES get scaffold='NONE'."""
        with connect(migrated_db) as conn:
            conn.execute(
                """INSERT INTO compounds
                (canonical_smiles, inchikey, inchikey_connectivity)
                VALUES ('INVALID_SMILES', 'BADKEY00000000000SA-N', 'BADKEY00000000000')"""
            )
            scaffolds = _compute_scaffolds(conn)
            assert "NONE" in scaffolds
            assert 1 in scaffolds["NONE"]


# ============================================================
# TestDegreeBalancedSplit
# ============================================================


class TestDegreeBalancedSplit:

    def test_all_pairs_assigned(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 10, 5)
            result = generate_degree_balanced_split(conn)
            assigned = sum(result["counts"].values())
            assert assigned == total

    def test_ratios_within_tolerance(self, migrated_db):
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 20, 10)
            result = generate_degree_balanced_split(conn)
            counts = result["counts"]
            assert abs(counts["train"] / total - 0.7) < 0.05
            assert abs(counts["val"] / total - 0.1) < 0.05
            assert abs(counts["test"] / total - 0.2) < 0.05

    def test_deterministic(self, migrated_db):
        """Same seed should produce identical assignments."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)
            r1 = generate_degree_balanced_split(conn, seed=42)

        db2 = migrated_db.parent / "test2.db"
        create_database(db2, MIGRATIONS_DIR)
        with connect(db2) as conn:
            _populate_small_db(conn, 10, 5)
            r2 = generate_degree_balanced_split(conn, seed=42)

        assert r1["counts"] == r2["counts"]

    def test_degree_distribution_preserved(self, migrated_db):
        """Mean degree in each fold should be similar to overall mean."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 20, 10)
            result = generate_degree_balanced_split(conn)
            sid = result["split_id"]

            overall_mean = conn.execute(
                "SELECT AVG(compound_degree) FROM compound_target_pairs"
            ).fetchone()[0]

            for fold in ("train", "val", "test"):
                fold_mean = conn.execute(
                    """SELECT AVG(ctp.compound_degree)
                    FROM split_assignments sa
                    JOIN compound_target_pairs ctp ON sa.pair_id = ctp.pair_id
                    WHERE sa.split_id = ? AND sa.fold = ?""",
                    (sid, fold),
                ).fetchone()[0]
                # Mean degree per fold should be within 30% of overall
                assert abs(fold_mean - overall_mean) / overall_mean < 0.3


# ============================================================
# TestExportNegativeDataset
# ============================================================


class TestExportNegativeDataset:

    def test_parquet_roundtrip(self, migrated_db, tmp_path):
        """Exported Parquet has correct columns and row count."""
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 5, 3)
            generate_random_split(conn)

        export_dir = tmp_path / "exports"
        result = export_negative_dataset(
            migrated_db, export_dir,
            split_strategies=["random"],
        )
        assert result["total_rows"] == total

        df = pd.read_parquet(result["parquet_path"])
        assert len(df) == total
        assert "smiles" in df.columns
        assert "uniprot_id" in df.columns
        assert "split_random" in df.columns
        assert (df["Y"] == 0).all()

    def test_splits_csv_created(self, migrated_db, tmp_path):
        """Lightweight splits CSV is created with correct columns."""
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 5, 3)
            generate_random_split(conn)

        export_dir = tmp_path / "exports"
        result = export_negative_dataset(
            migrated_db, export_dir,
            split_strategies=["random"],
        )
        df = pd.read_csv(result["splits_csv_path"])
        assert len(df) == total
        assert "pair_id" in df.columns
        assert "smiles" in df.columns
        assert "split_random" in df.columns
        # target_sequence should NOT be in splits CSV
        assert "target_sequence" not in df.columns

    def test_multiple_splits(self, migrated_db, tmp_path):
        """Export works with multiple split strategies."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 5, 3)
            generate_random_split(conn)
            generate_cold_compound_split(conn)

        export_dir = tmp_path / "exports"
        result = export_negative_dataset(
            migrated_db, export_dir,
            split_strategies=["random", "cold_compound"],
        )
        df = pd.read_parquet(result["parquet_path"])
        assert "split_random" in df.columns
        assert "split_cold_compound" in df.columns

    def test_no_splits_present(self, migrated_db, tmp_path):
        """Export works even when no splits have been generated."""
        with connect(migrated_db) as conn:
            total = _populate_small_db(conn, 3, 2)

        export_dir = tmp_path / "exports"
        result = export_negative_dataset(
            migrated_db, export_dir,
            split_strategies=["random"],
        )
        df = pd.read_parquet(result["parquet_path"])
        assert len(df) == total
        # split_random should be NULL/None for all rows
        assert df["split_random"].isna().all()


# ============================================================
# TestMergePositiveNegative
# ============================================================


def _make_positives(n=20, uniprot_ids=None):
    """Create a synthetic positives DataFrame for testing."""
    if uniprot_ids is None:
        uniprot_ids = [f"P{i:05d}" for i in range(1, 4)]
    rows = []
    for i in range(n):
        rows.append({
            "smiles": f"POS_C{i}",
            "inchikey": f"POS{i:011d}SA-N",
            "uniprot_id": uniprot_ids[i % len(uniprot_ids)],
            "target_sequence": "MAAAA",
            "pchembl_value": 7.0 + i * 0.01,
            "activity_type": "IC50",
            "activity_value_nm": 100.0,
            "publication_year": 2020,
        })
    return pd.DataFrame(rows)


class TestMergePositiveNegative:

    def test_balanced_output(self, migrated_db, tmp_path):
        """Balanced merge produces equal pos/neg counts."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)

        positives = _make_positives(n=15)
        result = merge_positive_negative(
            positives, migrated_db, tmp_path / "m1"
        )
        df = pd.read_parquet(result["balanced"]["path"])
        assert result["balanced"]["n_pos"] == result["balanced"]["n_neg"]
        assert (df["Y"].isin([0, 1])).all()
        assert df["Y"].sum() == result["balanced"]["n_pos"]

    def test_realistic_ratio(self, migrated_db, tmp_path):
        """Realistic merge has ~1:10 pos:neg ratio."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 20, 10)  # 200 negatives

        positives = _make_positives(n=15)
        result = merge_positive_negative(
            positives, migrated_db, tmp_path / "m1"
        )
        assert result["realistic"]["n_neg"] == result["realistic"]["n_pos"] * 10

    def test_overlap_removal(self, migrated_db, tmp_path):
        """Overlapping pairs are removed from positives."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 5, 3)
            # Get actual inchikeys and uniprots from DB
            neg_pairs = conn.execute(
                """SELECT c.inchikey, t.uniprot_accession
                FROM compound_target_pairs ctp
                JOIN compounds c ON ctp.compound_id = c.compound_id
                JOIN targets t ON ctp.target_id = t.target_id
                LIMIT 2"""
            ).fetchall()

        # Create positives that overlap with 2 negatives
        pos_data = []
        for ik, uid in neg_pairs:
            pos_data.append({
                "smiles": "OVERLAP",
                "inchikey": ik,
                "uniprot_id": uid,
                "target_sequence": "MAAAA",
                "pchembl_value": 8.0,
                "activity_type": "IC50",
                "activity_value_nm": 10.0,
                "publication_year": 2022,
            })
        # Add non-overlapping positives
        for i in range(10):
            pos_data.append({
                "smiles": f"UNIQUE_C{i}",
                "inchikey": f"UNIQ{i:011d}SA-N",
                "uniprot_id": "P00001",
                "target_sequence": "MAAAA",
                "pchembl_value": 7.5,
                "activity_type": "IC50",
                "activity_value_nm": 30.0,
                "publication_year": 2021,
            })
        positives = pd.DataFrame(pos_data)

        result = merge_positive_negative(
            positives, migrated_db, tmp_path / "m1"
        )
        # The 2 overlapping should have been removed
        # Balanced should use non-overlapping positives only
        assert result["balanced"]["n_pos"] == 10

    def test_empty_positives(self, migrated_db, tmp_path):
        """Empty positives produces empty datasets."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 5, 3)

        positives = pd.DataFrame(columns=[
            "smiles", "inchikey", "uniprot_id", "target_sequence", "Y",
        ])
        result = merge_positive_negative(
            positives, migrated_db, tmp_path / "m1"
        )
        assert result["balanced"]["total"] == 0


# ============================================================
# TestLeakageReport
# ============================================================


class TestLeakageReport:

    def test_report_structure(self, migrated_db):
        """Report has all expected top-level keys."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)
            generate_random_split(conn)
            generate_cold_compound_split(conn)
            generate_cold_target_split(conn)

        report = generate_leakage_report(migrated_db)
        assert "db_summary" in report
        assert "splits" in report
        assert "cold_split_integrity" in report
        assert report["db_summary"]["pairs"] == 50

    def test_cold_splits_zero_leakage(self, migrated_db):
        """Cold splits in report should show zero leakage."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 20, 5)
            generate_cold_compound_split(conn)
            generate_cold_target_split(conn)

        report = generate_leakage_report(migrated_db)
        integrity = report["cold_split_integrity"]
        assert integrity["cold_compound"]["leaks"] == 0
        assert integrity["cold_target"]["leaks"] == 0

    def test_writes_json(self, migrated_db, tmp_path):
        """Report can be written to JSON file."""
        import json

        with connect(migrated_db) as conn:
            _populate_small_db(conn, 5, 3)

        json_path = tmp_path / "report.json"
        generate_leakage_report(migrated_db, output_path=json_path)
        assert json_path.exists()

        with open(json_path) as f:
            data = json.load(f)
        assert data["db_summary"]["compounds"] == 5

    def test_split_ratios_in_report(self, migrated_db):
        """Split ratios appear in report."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 20, 10)
            generate_random_split(conn)

        report = generate_leakage_report(migrated_db)
        random_split = report["splits"]["random_v1"]
        assert abs(random_split["ratios"]["train"] - 0.7) < 0.05


# ============================================================
# TestDataFrameSplits (M1 split functions)
# ============================================================


def _make_m1_df(n_pos=100, n_neg=100, n_compounds=20, n_targets=5):
    """Create a synthetic M1-like DataFrame for testing splits."""
    rows = []
    for i in range(n_pos):
        cid = i % n_compounds
        tid = i % n_targets
        rows.append({
            "smiles": f"POS{cid}",
            "inchikey": f"POS{cid:011d}SA-N",
            "uniprot_id": f"P{tid:05d}",
            "target_sequence": "MAAAA",
            "Y": 1,
        })
    for i in range(n_neg):
        cid = i % n_compounds
        tid = i % n_targets
        rows.append({
            "smiles": f"NEG{cid}",
            "inchikey": f"NEG{cid:011d}SA-N",
            "uniprot_id": f"P{tid:05d}",
            "target_sequence": "MAAAA",
            "Y": 0,
        })
    return pd.DataFrame(rows)


class TestDataFrameSplits:

    def test_random_split_columns(self):
        """add_random_split adds split_random column."""
        df = _make_m1_df()
        result = add_random_split(df)
        assert "split_random" in result.columns
        assert set(result["split_random"].unique()) == {"train", "val", "test"}

    def test_random_split_ratios(self):
        """Random split has approximately 70/10/20 ratios."""
        df = _make_m1_df(n_pos=500, n_neg=500)
        result = add_random_split(df)
        counts = result["split_random"].value_counts()
        total = len(result)
        assert abs(counts["train"] / total - 0.7) < 0.05
        assert abs(counts["val"] / total - 0.1) < 0.05
        assert abs(counts["test"] / total - 0.2) < 0.05

    def test_random_split_deterministic(self):
        """Same seed produces identical splits."""
        df = _make_m1_df()
        r1 = add_random_split(df, seed=42)
        r2 = add_random_split(df, seed=42)
        assert (r1["split_random"] == r2["split_random"]).all()

    def test_cold_compound_no_leak(self):
        """Cold-compound split: no compound in both train and test."""
        df = _make_m1_df(n_pos=200, n_neg=200, n_compounds=30)
        result = add_cold_compound_split(df)
        train_compounds = set(
            result[result["split_cold_compound"] == "train"]["inchikey"].str[:14]
        )
        test_compounds = set(
            result[result["split_cold_compound"] == "test"]["inchikey"].str[:14]
        )
        assert len(train_compounds & test_compounds) == 0

    def test_cold_compound_no_leak_val(self):
        """Cold-compound split: no compound in both val and test."""
        df = _make_m1_df(n_pos=200, n_neg=200, n_compounds=30)
        result = add_cold_compound_split(df)
        val_compounds = set(
            result[result["split_cold_compound"] == "val"]["inchikey"].str[:14]
        )
        test_compounds = set(
            result[result["split_cold_compound"] == "test"]["inchikey"].str[:14]
        )
        assert len(val_compounds & test_compounds) == 0

    def test_cold_target_no_leak(self):
        """Cold-target split: no target in both train and test."""
        df = _make_m1_df(n_pos=200, n_neg=200, n_targets=10)
        result = add_cold_target_split(df)
        train_targets = set(
            result[result["split_cold_target"] == "train"]["uniprot_id"]
        )
        test_targets = set(
            result[result["split_cold_target"] == "test"]["uniprot_id"]
        )
        assert len(train_targets & test_targets) == 0

    def test_apply_m1_splits_all_columns(self):
        """apply_m1_splits adds all 3 split columns."""
        df = _make_m1_df()
        result = apply_m1_splits(df)
        assert "split_random" in result.columns
        assert "split_cold_compound" in result.columns
        assert "split_cold_target" in result.columns

    def test_empty_dataframe(self):
        """Split functions handle empty DataFrames gracefully."""
        df = pd.DataFrame(columns=[
            "smiles", "inchikey", "uniprot_id", "target_sequence", "Y",
        ])
        result = apply_m1_splits(df)
        assert len(result) == 0
        assert "split_random" in result.columns

    def test_original_not_modified(self):
        """Split functions do not modify the original DataFrame."""
        df = _make_m1_df()
        original_cols = set(df.columns)
        _ = add_random_split(df)
        assert set(df.columns) == original_cols


class TestMergeWithSplits:

    def test_balanced_has_split_columns(self, migrated_db, tmp_path):
        """Balanced merge output has split columns."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)

        positives = _make_positives(n=15)
        result = merge_positive_negative(
            positives, migrated_db, tmp_path / "m1"
        )
        df = pd.read_parquet(result["balanced"]["path"])
        assert "split_random" in df.columns
        assert "split_cold_compound" in df.columns
        assert "split_cold_target" in df.columns

    def test_realistic_has_split_columns(self, migrated_db, tmp_path):
        """Realistic merge output has split columns."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 20, 10)

        positives = _make_positives(n=15)
        result = merge_positive_negative(
            positives, migrated_db, tmp_path / "m1"
        )
        df = pd.read_parquet(result["realistic"]["path"])
        assert "split_random" in df.columns
        assert "split_cold_compound" in df.columns
        assert "split_cold_target" in df.columns


# ============================================================
# TestRandomNegatives (Exp 1 controls)
# ============================================================


class TestUniformRandomNegatives:

    def test_generates_correct_count(self, migrated_db, tmp_path):
        """Uniform random generates requested number of negatives."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 6)])
        result = generate_uniform_random_negatives(
            migrated_db, positives, n_samples=20,
            output_dir=tmp_path / "rand",
        )
        df = pd.read_parquet(result["path"])
        # balanced: min(10 pos, 20 neg) = 10 each → 20 total
        assert result["n_pos"] == 10
        assert result["n_neg"] == 10
        assert result["total"] == 20

    def test_no_overlap_with_tested(self, migrated_db, tmp_path):
        """Generated pairs do not exist in NegBioDB or positives."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)
            # Load tested pairs
            tested = set()
            for row in conn.execute(
                """SELECT c.inchikey_connectivity, t.uniprot_accession
                FROM compound_target_pairs ctp
                JOIN compounds c ON ctp.compound_id = c.compound_id
                JOIN targets t ON ctp.target_id = t.target_id"""
            ):
                tested.add((row[0], row[1]))

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 6)])
        for ik, uid in zip(positives["inchikey"].str[:14], positives["uniprot_id"]):
            tested.add((ik, uid))

        result = generate_uniform_random_negatives(
            migrated_db, positives, n_samples=30,
            output_dir=tmp_path / "rand",
        )
        df = pd.read_parquet(result["path"])
        neg_df = df[df["Y"] == 0]
        for _, row in neg_df.iterrows():
            key = (row["inchikey"][:14], row["uniprot_id"])
            assert key not in tested, f"Generated pair {key} is in tested set"

    def test_has_split_columns(self, migrated_db, tmp_path):
        """Output has M1 split columns."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 6)])
        result = generate_uniform_random_negatives(
            migrated_db, positives, n_samples=20,
            output_dir=tmp_path / "rand",
        )
        df = pd.read_parquet(result["path"])
        assert "split_random" in df.columns
        assert "split_cold_compound" in df.columns
        assert "split_cold_target" in df.columns

    def test_deterministic(self, migrated_db, tmp_path):
        """Same seed produces identical output."""
        with connect(migrated_db) as conn:
            _populate_small_db(conn, 10, 5)

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 6)])
        r1 = generate_uniform_random_negatives(
            migrated_db, positives, n_samples=15,
            output_dir=tmp_path / "r1", seed=42,
        )
        r2 = generate_uniform_random_negatives(
            migrated_db, positives, n_samples=15,
            output_dir=tmp_path / "r2", seed=42,
        )
        df1 = pd.read_parquet(r1["path"])
        df2 = pd.read_parquet(r2["path"])
        pd.testing.assert_frame_equal(df1, df2)


class TestDegreeMatchedNegatives:
    """Degree-matched tests use _populate_partial_db (sparse graph)
    because generate_degree_matched_negatives only samples from DB
    compounds.  _populate_small_db creates ALL pairs → 0 untested.
    """

    def test_generates_output(self, migrated_db, tmp_path):
        """Degree-matched generates a non-empty output."""
        with connect(migrated_db) as conn:
            _populate_partial_db(conn, 20, 10, pairs_per_compound=3)

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 11)])
        result = generate_degree_matched_negatives(
            migrated_db, positives, n_samples=20,
            output_dir=tmp_path / "deg",
        )
        df = pd.read_parquet(result["path"])
        assert len(df) > 0
        assert (df["Y"].isin([0, 1])).all()

    def test_has_split_columns(self, migrated_db, tmp_path):
        """Output has M1 split columns."""
        with connect(migrated_db) as conn:
            _populate_partial_db(conn, 20, 10, pairs_per_compound=3)

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 11)])
        result = generate_degree_matched_negatives(
            migrated_db, positives, n_samples=20,
            output_dir=tmp_path / "deg",
        )
        df = pd.read_parquet(result["path"])
        assert "split_random" in df.columns
        assert "split_cold_compound" in df.columns

    def test_no_overlap_with_tested(self, migrated_db, tmp_path):
        """Generated pairs do not exist in tested set."""
        with connect(migrated_db) as conn:
            _populate_partial_db(conn, 20, 10, pairs_per_compound=3)
            tested = set()
            for row in conn.execute(
                """SELECT c.inchikey_connectivity, t.uniprot_accession
                FROM compound_target_pairs ctp
                JOIN compounds c ON ctp.compound_id = c.compound_id
                JOIN targets t ON ctp.target_id = t.target_id"""
            ):
                tested.add((row[0], row[1]))

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 11)])
        for ik, uid in zip(positives["inchikey"].str[:14], positives["uniprot_id"]):
            tested.add((ik, uid))

        result = generate_degree_matched_negatives(
            migrated_db, positives, n_samples=20,
            output_dir=tmp_path / "deg",
        )
        df = pd.read_parquet(result["path"])
        neg_df = df[df["Y"] == 0]
        for _, row in neg_df.iterrows():
            key = (row["inchikey"][:14], row["uniprot_id"])
            assert key not in tested

    def test_deterministic(self, migrated_db, tmp_path):
        """Same seed produces identical output."""
        with connect(migrated_db) as conn:
            _populate_partial_db(conn, 20, 10, pairs_per_compound=3)

        positives = _make_positives(n=10, uniprot_ids=[f"P{i:05d}" for i in range(1, 11)])
        r1 = generate_degree_matched_negatives(
            migrated_db, positives, n_samples=15,
            output_dir=tmp_path / "r1", seed=42,
        )
        r2 = generate_degree_matched_negatives(
            migrated_db, positives, n_samples=15,
            output_dir=tmp_path / "r2", seed=42,
        )
        df1 = pd.read_parquet(r1["path"])
        df2 = pd.read_parquet(r2["path"])
        pd.testing.assert_frame_equal(df1, df2)