# Calling Cards Region Quantification
# 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 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
#
# Usage:
#   Rscript quantify_regions.R

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
  )

  message("Calculating log hypergeometric p-values...")
  mcols(regions_gr)$log_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,
    log.p = TRUE
  )

  # 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 -----------------------------------------------------------

PROMOTERS = 'start_codon_500bp'

genomic_features = arrow::read_parquet("~/code/hf/yeast_genome_resources/brentlab_features.parquet")

genome_map_replicate_ds = arrow::open_dataset("~/code/hf/callingcards/genome_map", unify_schemas = TRUE)
genome_map_replicate_meta = arrow::read_parquet("~/code/hf/callingcards/genome_map_meta.parquet")

background_gr <- read_tsv("~/code/hf/callingcards/adh1_background_ucsc.qbed") |>
    mutate(id = "adh1_bg",
           score = scales::rescale(depth, to = c(1,1000))) |>
    dplyr::select(chr, start, end, id, score, strand) |>
    bed_to_granges()


regions_list = list(
    yiming = read_tsv("~/code/hf/yeast_genome_resources/yiming_promoters.bed",
                      col_names = c('chr', 'start', 'end', 'locus_tag', 'score', 'strand')) %>%
        bed_to_granges(),
    mindel =  arrow::read_parquet("~/code/hf/yeast_genome_resources/mindel_promoters.parquet",
                                  col_names = c('chr', 'start', 'end', 'locus_tag', 'score', 'strand')) %>%
        bed_to_granges(),
    start_codon_500bp = rtracklayer::import("~/code/hf/yeast_genome_resources/start_codon_500bp_upstream_promoters.bed"),
    intergenic = rtracklayer::import("~/code/hf/yeast_genome_resources/intergenic_regions_5_1.bed")
)

# rename name to target_locus_tag
colnames(GenomicRanges::mcols(regions_list$yiming))[1] <- "target_locus_tag"
colnames(GenomicRanges::mcols(regions_list$start_codon_500bp))[1] <- "target_locus_tag"

intergenic_meta = read_csv("~/code/hf/yeast_genome_resources/intergenic_regions_metadata_5_1.csv") |>
    dplyr::select(ir_name, chr, start, end, feature_left, feature_right) |>
    pivot_longer(-c(ir_name, chr, start, end), names_to = 'side', values_to = 'target_locus_tag') |>
    left_join(dplyr::select(genomic_features, target_locus_tag = locus_tag,
                            target_symbol = symbol, target_strand = strand,
                            target_start = start, target_end = end)) |>
    filter(chr != "chrM") |>
    filter(!is.na(target_strand)) |>
    mutate(valid = (target_strand == '-' & target_end <= start)
           | (target_strand == '+' & target_start >= end)) |>
    filter(valid)

regions_gr <- regions_list[[PROMOTERS]]

# removes AAD6 and AAD16 from mindel. pseudogene no longer in annotations
if(PROMOTERS != "intergenic"){
    # really just for mindel
    regions_gr = regions_gr[!is.na(regions_gr$target_locus_tag)]
} else if(PROMOTERS == "intergenic"){
    regions_gr = regions_gr[regions_gr$name %in% unique(intergenic_meta$ir_name)]
}
library(parallel)

n_cores = 25


results_replicates <- mclapply(
    genome_map_replicate_meta$id,
    \(x) enrichment_analysis(
        experiment_gr = genome_map_replicate_ds |>
            filter(id == x) |>
            collect() |>
            dplyr::rename(score = depth) |>
            relocate(chr, start, end, id, score, strand) |>
            mutate(depth = scales::rescale(score, to = c(1, 1000))) |>
            bed_to_granges(),
        background_gr = background_gr,
        regions_gr = regions_gr,
        deduplicate_experiment = TRUE,
        pseudocount = 0.1
    ),
    mc.cores = n_cores
)
names(results_replicates) = genome_map_replicate_meta$id


if(PROMOTERS == "intergenic"){

    results_replicates_df = bind_rows(map(results_replicates, as_tibble), .id = "genome_map_id") |>
        mutate(genome_map_id = as.integer(genome_map_id)) |>
        dplyr::rename(ir_name = name) |>
        left_join(dplyr::select(intergenic_meta, ir_name, target_locus_tag, target_symbol),
                  relationship = "many-to-many") |>
        left_join(genome_map_replicate_meta,
              by = c("genome_map_id" = "id")) |>
        select(genome_map_id, batch,
               target_locus_tag, target_symbol, ir_name,
               experiment_hops, background_hops,
               total_background_hops, total_experiment_hops,
               callingcards_enrichment,
               poisson_pval, log_poisson_pval, poisson_qval,
               hypergeometric_pval, log_hypergeometric_pval, hypergeometric_qval) |>
        mutate(genome_map_id = as.integer(genome_map_id))

    arrow::write_dataset(
        results_replicates_df,
        path = "/home/chase/code/hf/callingcards/annotated_feature_reprocess_intergenic",
        format = "parquet",
        partitioning = c("batch"),
        existing_data_behavior = "overwrite",
        compression = "zstd",
        write_statistics = TRUE,
        use_dictionary = c(
            genome_map_id = TRUE
        )
      )

} else if(PROMOTERS == "start_codon_500bp"){


results_replicates_df = bind_rows(map(results_replicates, as_tibble), .id = "genome_map_id") |>
    mutate(genome_map_id = as.integer(genome_map_id)) |>
    left_join(dplyr::select(genomic_features, target_locus_tag = locus_tag, target_symbol = symbol)) |>
    left_join(genome_map_replicate_meta,
              by = c("genome_map_id" = "id")) |>
    select(genome_map_id, batch,
           target_locus_tag, target_symbol,
           experiment_hops, background_hops,
           total_background_hops, total_experiment_hops,
           callingcards_enrichment,
           poisson_pval, log_poisson_pval, poisson_qval,
           hypergeometric_pval, log_hypergeometric_pval, hypergeometric_qval) |>
    mutate(genome_map_id = as.integer(genome_map_id))

arrow::write_dataset(
    results_replicates_df,
    path = "/home/chase/code/hf/callingcards/annotated_feature_reprocess_start_codon_500",
    format = "parquet",
    partitioning = c("batch"),
    existing_data_behavior = "overwrite",
    compression = "zstd",
    write_statistics = TRUE,
    use_dictionary = c(
        genome_map_id = TRUE
    )
  )

}

# creating the combined data for a new set

passing_rep_gm_ids <- unlist(strsplit(unique(arrow::read_parquet("~/code/hf/callingcards/2026_analysis_set.parquet")$gm_id), "-"))

genome_map_replicate_meta_combined = genome_map_replicate_meta |>
    filter(id %in% passing_rep_gm_ids) |>
    group_by(regulator_locus_tag, regulator_symbol, condition) |>
    mutate(id = as.character(id)) |>
    reframe(combined_id = if (n() > 1) paste(id, collapse = "-") else id)

# # Run analysis with deduplication (default for calling cards)
results_combined <- map(genome_map_replicate_meta_combined$combined_id, ~{
    # get list of ids (might just be 1)
    ids <- as.integer(strsplit(.x, "-")[[1]])
    ids <- ids[!is.na(ids)]

    # for each id, produce a GRanges
    combined_passing_set <- map(ids, ~{
        genome_map_replicate_ds |>
            filter(id == .x) |>
            collect() |>
            dplyr::rename(score = depth) |>
            relocate(chr, start, end, id, score, strand) |>
            mutate(depth = scales::rescale(score, to = c(1, 1000))) |>
            bed_to_granges() |>
            deduplicate_granges()
    })

    # combine the list into a single gr
    combined_gr <- do.call(c, combined_passing_set)

    enrichment_analysis(
        experiment_gr = combined_gr,
        background_gr = background_gr,
        regions_gr = regions_gr,
        deduplicate_experiment = FALSE,
        pseudocount = 0.1
    )
})
names(results_combined) = genome_map_replicate_meta_combined$combined_id

if(PROMOTERS == 'intergenic'){
  results_combined_analysis_df = bind_rows(map(results_combined, as_tibble), .id = "combined_id") |>
    dplyr::rename(ir_name = name) |>
    left_join(dplyr::select(intergenic_meta, ir_name, target_locus_tag, target_symbol),
        relationship = "many-to-many") |>
    left_join(genome_map_replicate_meta_combined) |>
    select(combined_id,
           regulator_locus_tag, regulator_symbol, condition,
           target_locus_tag, target_symbol, experiment_hops, background_hops,
           total_background_hops, total_experiment_hops,
           callingcards_enrichment,
           poisson_pval, log_poisson_pval, poisson_qval,
           hypergeometric_pval, log_hypergeometric_pval, hypergeometric_qval) |>
    filter(condition == "standard")

    results_combined_analysis_df |>
        ungroup() |>
        dplyr::select(-condition) |>
        arrange(regulator_locus_tag) |>
        arrow::write_parquet(
            "/home/chase/code/hf/callingcards/annotated_feature_reprocess_intergenic_analysis.parquet",
            compression = "zstd",
            write_statistics = TRUE,
            use_dictionary = TRUE
        )

} else if(PROMOTERS == "start_codon_500bp"){
  results_combined_analysis_df = bind_rows(map(results_combined, as_tibble), .id = "combined_id") |>
    left_join(dplyr::select(genomic_features, target_locus_tag = locus_tag, target_symbol = symbol)) |>
    left_join(genome_map_replicate_meta_combined) |>
    select(combined_id,
           regulator_locus_tag, regulator_symbol, condition,
           target_locus_tag, target_symbol, experiment_hops, background_hops,
           total_background_hops, total_experiment_hops,
           callingcards_enrichment,
           poisson_pval, log_poisson_pval, poisson_qval,
           hypergeometric_pval, log_hypergeometric_pval, hypergeometric_qval) |>
    filter(condition == "standard")

    results_combined_analysis_df |>
        ungroup() |>
        dplyr::select(-condition) |>
        arrange(regulator_locus_tag) |>
        arrow::write_parquet(
            "/home/chase/code/hf/callingcards/annotated_feature_reprocess_start_codon_500bp_analysis.parquet",
            compression = "zstd",
            write_statistics = TRUE,
            use_dictionary = TRUE
        )

}