STRATA — DC1: Software Artifacts Mining (Data Collection I)

from datetime import datetime
from typing import Optional, Iterable, Tuple
from git import Repo
from . import db_utils

def upsert_commit(repo_commit) -> int:
  """Insert commit if missing and return its DB primary-key id.

  Behavior:
  - Build a dict with `hash`, `author_name`, `message`, `timestamp`.
  - INSERT ... ON CONFLICT DO NOTHING RETURNING id; if no row is
    returned, SELECT id FROM commits WHERE commit_hash=%(hash)s.
  - Return the integer id.
  """

def insert_parents(commit_id: int, parents: Iterable[str]) -> None:
  """Record parent links for `commit_id`.

  Insert rows into `commit_parents(commit_id, parent_hash)` using
  `ON CONFLICT DO NOTHING` to keep the operation idempotent.
  """

def insert_stats(commit_id: int, repo_commit) -> None:
  """Insert aggregate stats for a commit.

  Use `repo_commit.stats.total` (or default zeros) and write into
  `commit_stats(commit_id, files_changed, insertions, deletions)` with
  `ON CONFLICT (commit_id) DO NOTHING`.
  """

def insert_files(commit_id: int, repo_commit) -> None:
  """Insert per-file change rows for a commit.

  General structure (implement this pattern):

  - Obtain per-file stats dict:
    files = getattr(repo_commit.stats, 'files', {}) or {}

  - Attempt to infer change types via a diff to the parent commit:
    change_types = {}
    try:
      parent = repo_commit.parents[0] if repo_commit.parents else None
      if parent is not None:
        for diff in parent.diff(repo_commit):
          # set change_types[diff.b_path or diff.a_path]
          # to diff.change_type.upper() (A/M/D/R/T)
          # Note: `diff.b_path` is the path in the new commit (useful for
          # additions/renames); `diff.a_path` is the path in the parent (useful
          # for deletions). Preferring `b_path` records the post-change path,
          # while falling back to `a_path` preserves the old path when the file
          # was removed.
      else:
        # root commit: mark all paths in `files` as 'A'
        for path in files.keys():
          change_types[path] = 'A'
    except Exception:
      # If diffing fails, fall back to a conservative default
      # (e.g. treat unknown files as 'M') and continue.
      pass

  - For each (path, data) in `files.items()`:
    # compute additions = int(data.get('insertions', 0))
    # compute deletions = int(data.get('deletions', 0))
    # choose change_type = change_types.get(path, 'M')
    # INSERT into `commit_files(commit_id, file_path, change_type, additions, deletions)`
    # using `ON CONFLICT DO NOTHING` keyed by (commit_id, file_path).

  The goal is to be best-effort and idempotent; tests will assert
  that rows exist with non-negative additions/deletions and reasonable
  change_type values.
  """

def insert_run_log(repo_path: str, head_hash: str, commit_count: int) -> None:
  """Append a provenance row to `run_log`.

  Write `repo_path`, `head_hash`, and `commit_count`. `started_at` can
  be a DB default of `now()`.

  Motivation: when mining software repositories for research it's
  important to record provenance for reproducibility, auditing, and
  debugging. Recording the `repo_path`, the `head_hash` observed after a
  run, and the `commit_count` lets future analysts tie database rows to a
  specific repository state (commit SHA) and run. This supports:
  - reproducing results by checking out the recorded `head_hash`;
  - detecting incomplete runs or partial replays by comparing counts;
  - auditing which repository snapshot produced the stored facts.
  """

def validate_invariants() -> Tuple[int, int, int]:
  """Return (n_commits, n_stats, n_orphan_parents).

  Tests use this to assert `n_stats == n_commits` and `n_orphan_parents == 0`. Example of how to do orphans below.
  n_orphan_parents = db_utils.exec_get_one(
    "SELECT COUNT(*) FROM commit_parents cp WHERE NOT EXISTS (SELECT 1 FROM commits c WHERE c.commit_hash = cp.parent_hash);"
)[0]
  """

def mine_history(repo_path: str = ".", max_commits: Optional[int] = None, record_run: bool = True) -> int:
  """Traverse commit history and persist commits, stats, files, and parents.

  Processing order: oldest -> newest so the HEAD commit receives the highest id.
  Idempotent: uses unique(commit_hash) and ON CONFLICT safeguards.
  Returns: number of commits traversed this call (not newly inserted).
  """
  with Repo(repo_path) as repo:
    commits = list(repo.iter_commits("HEAD"))  # newest -> oldest
    commits.reverse()  # oldest -> newest
    count = 0
    for c in commits:
      cid = upsert_commit(c)
      insert_parents(cid, [p.hexsha for p in c.parents])
      insert_stats(cid, c)
      insert_files(cid, c)
      count += 1
      if max_commits is not None and count >= max_commits:
        break
    if record_run:
      head_hash = repo.head.commit.hexsha  # capture after processing
      insert_run_log(repo_path, head_hash, count)
    return count

-- Drop existing tables to ensure a clean schema before creating objects. There are many other ways to do this, but I'm making it explicit here for your convenience
DROP TABLE IF EXISTS run_log CASCADE;
DROP TABLE IF EXISTS commit_parents CASCADE;
DROP TABLE IF EXISTS commit_files CASCADE;
DROP TABLE IF EXISTS commit_stats CASCADE;
DROP TABLE IF EXISTS commits CASCADE;

CREATE TABLE IF NOT EXISTS commits (
    id SERIAL PRIMARY KEY,
    commit_hash TEXT NOT NULL,
    author_name TEXT NOT NULL,
    message TEXT NOT NULL,
    commit_ts TIMESTAMP NOT NULL
);
-- Ensure no duplicate commits by hash
CREATE UNIQUE INDEX IF NOT EXISTS idx_commits_hash ON commits(commit_hash);

-- Per-commit aggregate stats
CREATE TABLE IF NOT EXISTS commit_stats (
    commit_id INTEGER PRIMARY KEY REFERENCES commits(id) ON DELETE CASCADE,
    files_changed INTEGER NOT NULL,
    insertions INTEGER NOT NULL,
    deletions INTEGER NOT NULL
);

-- Per-file change details for each commit
CREATE TABLE IF NOT EXISTS commit_files (
    id SERIAL PRIMARY KEY,
    commit_id INTEGER NOT NULL REFERENCES commits(id) ON DELETE CASCADE,
    file_path TEXT NOT NULL,
    change_type TEXT NOT NULL,         -- 'A','M','D','R' (added, modified, deleted, renamed) best-effort from GitPython stats
    additions INTEGER DEFAULT 0,
    deletions INTEGER DEFAULT 0
);
-- Ensure idempotent inserts per (commit_id, file_path)
CREATE UNIQUE INDEX IF NOT EXISTS uq_commit_files_commit_path ON commit_files(commit_id, file_path);

-- Parent relationships (to support DAG traversals/merges)
CREATE TABLE IF NOT EXISTS commit_parents (
    commit_id INTEGER NOT NULL REFERENCES commits(id) ON DELETE CASCADE,
    parent_hash TEXT NOT NULL,
    PRIMARY KEY (commit_id, parent_hash)
);

CREATE TABLE IF NOT EXISTS run_log (
    id SERIAL PRIMARY KEY,
    started_at TIMESTAMP NOT NULL DEFAULT NOW(),
    repo_path TEXT NOT NULL,
    head_hash TEXT NOT NULL,
    commit_count INTEGER NOT NULL
);

def exec_commit_returning(sql, args={}):
    """Execute a write query that RETURNS rows (e.g., INSERT ... RETURNING)."""
    conn = connect()
    cur = conn.cursor()
    cur.execute(sql, args)
    rows = cur.fetchall()
    conn.commit()
    conn.close()
    return rows