scripts/barkai_annotated_features.R

# Quantifies enrichment of insertions/hops in genomic regions
#
# This script:
# 1. Counts insertions overlapping each genomic region (experiment and background)
# 2. Calculates enrichment scores
# 3. Computes z-score, Poisson and hypergeometric p-values
#
# Works with any data in BED3+ format (chr, start, end, ...)
# For calling cards: each insertion is counted once regardless of depth
#
# COORDINATE SYSTEMS:
# - Input BED files are assumed to be 0-indexed, half-open [start, end)
# - GenomicRanges uses 1-indexed, closed [start, end]
# - Conversion: GR_start = BED_start + 1, GR_end = BED_end

library(tidyverse)
library(GenomicRanges)

# Statistical Functions ---------------------------------------------------

#' Calculate enrichment (calling cards effect)
#'
#' @param total_background_hops Total number of hops in background (scalar or vector)
#' @param total_experiment_hops Total number of hops in experiment (scalar or vector)
#' @param background_hops Number of hops in background per region (vector)
#' @param experiment_hops Number of hops in experiment per region (vector)
#' @param pseudocount Pseudocount to avoid division by zero (default: 0.1)
#' @return Enrichment values
calculate_enrichment <- function(total_background_hops,
                                 total_experiment_hops,
                                 background_hops,
                                 experiment_hops,
                                 pseudocount = 0.1) {

  # Input validation
  if (!all(is.numeric(c(total_background_hops, total_experiment_hops,
                        background_hops, experiment_hops)))) {
    stop("All inputs must be numeric")
  }

  # Get the length of the region vectors
  n_regions <- length(background_hops)

  # Ensure experiment_hops is same length as background_hops
  if (length(experiment_hops) != n_regions) {
    stop("background_hops and experiment_hops must be the same length")
  }

  # Recycle scalar totals to match region length if needed
  if (length(total_background_hops) == 1) {
    total_background_hops <- rep(total_background_hops, n_regions)
  }
  if (length(total_experiment_hops) == 1) {
    total_experiment_hops <- rep(total_experiment_hops, n_regions)
  }

  # Now check all are same length
  if (length(total_background_hops) != n_regions ||
      length(total_experiment_hops) != n_regions) {
    stop("All input vectors must be the same length or scalars")
  }

  # Calculate enrichment
  numerator <- experiment_hops / total_experiment_hops
  denominator <- (background_hops + pseudocount) / total_background_hops
  enrichment <- numerator / denominator

  # Check for invalid values
  if (any(enrichment < 0, na.rm = TRUE)) {
    stop("Enrichment values must be non-negative")
  }
  if (any(is.na(enrichment))) {
    stop("Enrichment values must not be NA")
  }
  if (any(is.infinite(enrichment))) {
    stop("Enrichment values must not be infinite")
  }

  return(enrichment)
}


#' Calculate Poisson p-values
#'
#' @param total_background_hops Total number of hops in background (scalar or vector)
#' @param total_experiment_hops Total number of hops in experiment (scalar or vector)
#' @param background_hops Number of hops in background per region (vector)
#' @param experiment_hops Number of hops in experiment per region (vector)
#' @param pseudocount Pseudocount for lambda calculation (default: 0.1)
#' @param ... additional arguments to `ppois`. note that lower tail is set to FALSE
#'   already
#' @return Poisson p-values
calculate_poisson_pval <- function(total_background_hops,
                                   total_experiment_hops,
                                   background_hops,
                                   experiment_hops,
                                   pseudocount = 0.1,
                                   ...) {

  # Input validation
  if (!all(is.numeric(c(total_background_hops, total_experiment_hops,
                        background_hops, experiment_hops)))) {
    stop("All inputs must be numeric")
  }

  # Get the length of the region vectors
  n_regions <- length(background_hops)

  # Ensure experiment_hops is same length as background_hops
  if (length(experiment_hops) != n_regions) {
    stop("background_hops and experiment_hops must be the same length")
  }

  # Recycle scalar totals to match region length if needed
  if (length(total_background_hops) == 1) {
    total_background_hops <- rep(total_background_hops, n_regions)
  }
  if (length(total_experiment_hops) == 1) {
    total_experiment_hops <- rep(total_experiment_hops, n_regions)
  }

  # Now check all are same length
  if (length(total_background_hops) != n_regions ||
      length(total_experiment_hops) != n_regions) {
    stop("All input vectors must be the same length or scalars")
  }

  # Calculate hop ratio
  hop_ratio <- total_experiment_hops / total_background_hops

  # Calculate expected number of hops (mu/lambda parameter)
  # Add pseudocount to avoid mu = 0
  mu <- (background_hops + pseudocount) * hop_ratio

  # Observed hops in experiment
  x <- experiment_hops

  # Calculate p-value: P(X >= x) = 1 - P(X < x) = 1 - P(X <= x-1)
  # This is equivalent to: 1 - CDF(x) + PMF(x)
  # Using the upper tail directly with lower.tail = FALSE
  pval <- ppois(x - 1, lambda = mu, lower.tail = FALSE, ...)

  return(pval)
}


#' Calculate hypergeometric p-values
#'
#' @param total_background_hops Total number of hops in background (scalar or vector)
#' @param total_experiment_hops Total number of hops in experiment (scalar or vector)
#' @param background_hops Number of hops in background per region (vector)
#' @param experiment_hops Number of hops in experiment per region (vector)
#' @param ... additional arguments to phyper. Note that lower tail is set to
#'   false already
#' @return Hypergeometric p-values
calculate_hypergeom_pval <- function(total_background_hops,
                                     total_experiment_hops,
                                     background_hops,
                                     experiment_hops,
                                     ...) {

  # Input validation
  if (!all(is.numeric(c(total_background_hops, total_experiment_hops,
                        background_hops, experiment_hops)))) {
    stop("All inputs must be numeric")
  }

  # Get the length of the region vectors
  n_regions <- length(background_hops)

  # Ensure experiment_hops is same length as background_hops
  if (length(experiment_hops) != n_regions) {
    stop("background_hops and experiment_hops must be the same length")
  }

  # Recycle scalar totals to match region length if needed
  if (length(total_background_hops) == 1) {
    total_background_hops <- rep(total_background_hops, n_regions)
  }
  if (length(total_experiment_hops) == 1) {
    total_experiment_hops <- rep(total_experiment_hops, n_regions)
  }

  # Now check all are same length
  if (length(total_background_hops) != n_regions ||
      length(total_experiment_hops) != n_regions) {
    stop("All input vectors must be the same length or scalars")
  }

  # Hypergeometric parameters
  # M: total number of balls (total hops)
  M <- total_background_hops + total_experiment_hops
  # n: number of white balls (experiment hops)
  n <- total_experiment_hops
  # N: number of draws (hops in region)
  N <- background_hops + experiment_hops
  # x: number of white balls drawn (experiment hops in region) - 1 for upper tail
  x <- experiment_hops - 1

  # Handle edge cases
  valid <- (M >= 1) & (N >= 1)
  pval <- rep(1, length(M))

  # Calculate p-value for valid cases: P(X >= x) = 1 - P(X <= x-1)
  if (any(valid)) {
    pval[valid] <- phyper(x[valid], n[valid], M[valid] - n[valid], N[valid],
                          lower.tail = FALSE, ...)
  }

  return(pval)
}

# GRanges Conversion Functions --------------------------------------------

#' Convert BED format data frame to GRanges
#'
#' Handles coordinate system conversion from 0-indexed half-open BED format
#' to 1-indexed closed GenomicRanges format
#'
#' @param bed_df Data frame with chr, start, end columns in BED format (0-indexed, half-open)
#' @param zero_indexed Logical, whether input is 0-indexed (default: TRUE)
#' @return GRanges object
bed_to_granges <- function(bed_df, zero_indexed = TRUE) {

  if (!all(c("chr", "start", "end") %in% names(bed_df))) {
    stop("bed_df must have columns: chr, start, end")
  }

  # Convert from 0-indexed half-open [start, end) to 1-indexed closed [start, end]
  if (zero_indexed) {
    gr_start <- bed_df$start + 1
    gr_end <- bed_df$end
  } else {
    gr_start <- bed_df$start
    gr_end <- bed_df$end
  }

  # Create GRanges object (strand-agnostic for calling cards)
  gr <- GRanges(
    seqnames = bed_df$chr,
    ranges = IRanges(start = gr_start, end = gr_end),
    strand = "*"
  )

  # Add any additional metadata columns
  extra_cols <- setdiff(names(bed_df), c("chr", "start", "end", "strand"))
  if (length(extra_cols) > 0) {
    mcols(gr) <- bed_df[, extra_cols, drop = FALSE]
  }

  return(gr)
}


#' Deduplicate insertions in GRanges object
#'
#' For calling cards, if an insertion is found at the same coordinate,
#' only one record is retained
#'
#' @param gr GRanges object
#' @return Deduplicated GRanges object
deduplicate_granges <- function(gr) {
  # Find unique ranges (ignores strand and metadata)
  unique_ranges <- !duplicated(granges(gr))
  gr[unique_ranges]
}


#' Count overlaps between insertions and regions
#'
#' @param insertions_gr GRanges object with insertions
#' @param regions_gr GRanges object with regions
#' @param deduplicate Whether to deduplicate insertions (default: TRUE)
#' @return Integer vector of overlap counts per region
count_overlaps <- function(insertions_gr, regions_gr, deduplicate = TRUE) {

  # Deduplicate if requested
  if (deduplicate) {
    n_before <- length(insertions_gr)
    insertions_gr <- deduplicate_granges(insertions_gr)
    n_after <- length(insertions_gr)
    if (n_before != n_after) {
      message("   Deduplicated: ", n_before, " -> ", n_after,
              " (removed ", n_before - n_after, " duplicates)")
    }
  }

  # Count overlaps per region
  # countOverlaps returns an integer vector with one element per region
  counts <- countOverlaps(regions_gr, insertions_gr)

  return(counts)
}


# Main Analysis Function --------------------------------------------------

#' Call peaks/quantify regions using calling cards approach
#'
#' @param experiment_gr GRanges object with experiment insertions
#' @param background_gr GRanges object with background insertions
#' @param regions_gr GRanges object with regions to quantify
#' @param deduplicate_experiment Whether to deduplicate experiment insertions (default: TRUE)
#' @param pseudocount Pseudocount for calculations (default: 0.1)
#' @return GRanges object with regions and statistics as metadata columns
enrichment_analysis <- function(experiment_gr,
                                background_gr,
                                regions_gr,
                                deduplicate_experiment = TRUE,
                                pseudocount = 0.1) {

  message("Starting enrichment analysis...")

  # Validate inputs
  if (!inherits(experiment_gr, "GRanges")) {
    stop("experiment_gr must be a GRanges object")
  }
  if (!inherits(background_gr, "GRanges")) {
    stop("background_gr must be a GRanges object")
  }
  if (!inherits(regions_gr, "GRanges")) {
    stop("regions_gr must be a GRanges object")
  }

  # Count overlaps for experiment (with deduplication if requested)
  message("Counting experiment overlaps...")
  if (deduplicate_experiment) {
    message("   Deduplication: ON")
  } else {
    message("   Deduplication: OFF")
  }

  experiment_counts <- count_overlaps(
    experiment_gr, regions_gr,
    deduplicate = deduplicate_experiment
  )

  # Count overlaps for background (never deduplicated)
  message("Counting background overlaps...")
  message("   Deduplication: OFF (background should not be deduplicated)")

  background_counts <- count_overlaps(
    background_gr, regions_gr,
    deduplicate = FALSE
  )

  # Calculate total hops AFTER any deduplication
  if (deduplicate_experiment) {
    experiment_gr_dedup <- deduplicate_granges(experiment_gr)
    total_experiment_hops <- length(experiment_gr_dedup)
  } else {
    total_experiment_hops <- length(experiment_gr)
  }

  total_background_hops <- length(background_gr)

  message("Total experiment hops: ", total_experiment_hops)
  message("Total background hops: ", total_background_hops)

  if (total_experiment_hops == 0) {
    stop("Experiment data is empty")
  }
  if (total_background_hops == 0) {
    stop("Background data is empty")
  }

  # Add counts and totals as metadata columns
  mcols(regions_gr)$experiment_hops <- as.integer(experiment_counts)
  mcols(regions_gr)$background_hops <- as.integer(background_counts)
  mcols(regions_gr)$total_experiment_hops <- as.integer(total_experiment_hops)
  mcols(regions_gr)$total_background_hops <- as.integer(total_background_hops)

  # Calculate statistics
  message("Calculating enrichment scores...")
  mcols(regions_gr)$callingcards_enrichment <- calculate_enrichment(
    total_background_hops = total_background_hops,
    total_experiment_hops = total_experiment_hops,
    background_hops = background_counts,
    experiment_hops = experiment_counts,
    pseudocount = pseudocount
  )

  message("Calculating Poisson p-values...")
  mcols(regions_gr)$poisson_pval <- calculate_poisson_pval(
    total_background_hops = total_background_hops,
    total_experiment_hops = total_experiment_hops,
    background_hops = background_counts,
    experiment_hops = experiment_counts,
    pseudocount = pseudocount
  )

  message("Calculating log Poisson p-values...")
  mcols(regions_gr)$log_poisson_pval <- calculate_poisson_pval(
    total_background_hops = total_background_hops,
    total_experiment_hops = total_experiment_hops,
    background_hops = background_counts,
    experiment_hops = experiment_counts,
    pseudocount = pseudocount,
    log.p = TRUE
  )

  message("Calculating hypergeometric p-values...")
  mcols(regions_gr)$hypergeometric_pval <- calculate_hypergeom_pval(
    total_background_hops = total_background_hops,
    total_experiment_hops = total_experiment_hops,
    background_hops = background_counts,
    experiment_hops = experiment_counts
  )

  # Calculate adjusted p-values
  message("Calculating adjusted p-values...")
  mcols(regions_gr)$poisson_qval <- p.adjust(mcols(regions_gr)$poisson_pval, method = "fdr")
  mcols(regions_gr)$hypergeometric_qval <- p.adjust(mcols(regions_gr)$hypergeometric_pval, method = "fdr")

  message("Analysis complete!")

  return(regions_gr)
}


# Example Usage -----------------------------------------------------------

# This is a template for how to use these functions
# Uncomment and modify for your actual data

# # Load your data (BED3+ format: chr, start, end, ...)
experiment_gr = arrow::open_dataset("~/code/hf/barkai_compendium/genome_map")

accessions <- experiment_gr |>
  dplyr::select(accession) |>
  dplyr::distinct() |>
  dplyr::collect() |>
  dplyr::pull(accession)

tmp_acc = experiment_gr %>%
  filter(accession==accessions[1]) %>%
  collect()

mahendrawada_control_data_root = "~/projects/parsing_yeast_database_data/data/mahendrawada_chec"
background_gr_h_m_paths = list.files(mahendrawada_control_data_root)
background_gr_h_m = map(file.path(mahendrawada_control_data_root,
                                   background_gr_h_m_paths),
                        rtracklayer::import)
names(background_gr_h_m) = str_remove(background_gr_h_m_paths, "_REP1.mLb.mkD.sorted_5p.bed")

regions_gr <- read_tsv("~/code/hf/yeast_genome_resources/yiming_promoters.bed",
                       col_names = c('chr', 'start', 'end', 'locus_tag', 'score', 'strand'))  %>%
  bed_to_granges()

# # Run analysis with deduplication (default for calling cards)
results <- enrichment_analysis(
  experiment_gr = experiment_gr,
  background_gr = background_gr,
  regions_gr = regions_gr,
  deduplicate_experiment = TRUE,
  pseudocount = 0.1
)


# id 9 corresponds to the binding sample -- can get from genome_map and
# annotated_feature metadata
#
# NOTE: there are some expected differences due to a change in how I am handling
# the promoter boundaries. The implementation here is correct -- please use
# this from now on. If you need to compare or doubt something, please let
# me konw
#
# curr_db_annotated_feature = arrow::read_parquet("~/code/hf/callingcards/annotated_features/batch=run_5801/part-0.parquet") %>%
#   filter(id == 9)
#
# comp_df = curr_db_annotated_feature %>%
#   select(target_locus_tag, experiment_hops,
#          background_hops, background_total_hops,
#          experiment_total_hops) %>%
#   left_join(results %>%
#               as_tibble() %>%
#               select(locus_tag, total_background_hops,
#                      total_experiment_hops,
#                      experiment_hops, background_hops) %>%
#               dplyr::rename(target_locus_tag = locus_tag,
#                             new_exp_hops = experiment_hops,
#                             new_bg_hops = background_hops,
#                             new_bg_total = total_background_hops,
#                             new_expr_total = total_experiment_hops))