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

genomic_features <- arrow::read_parquet("~/projects/huggingface/yeast_genome_resources/brentlab_features.parquet")

genome_map_replicate_ds <- arrow::open_dataset("~/projects/huggingface/callingcards/genome_map", unify_schemas = TRUE)
genome_map_replicate_meta <- arrow::read_parquet("~/projects/huggingface/callingcards/genome_map_meta.parquet")

background_gr <- read_tsv("~/projects/huggingface/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("~/projects/huggingface/yeast_genome_resources/yiming_promoters.bed",
        col_names = c("chr", "start", "end", "locus_tag", "score", "strand")
    ) %>%
        bed_to_granges(),
    mindel = arrow::read_parquet("~/projects/huggingface/yeast_genome_resources/mindel_promoters.parquet",
        col_names = c("chr", "start", "end", "locus_tag", "score", "strand")
    ) %>%
        bed_to_granges(),
    start_codon_500bp = rtracklayer::import("~/projects/huggingface/yeast_genome_resources/start_codon_500bp_upstream_promoters.bed"),
    intergenic = rtracklayer::import("~/projects/huggingface/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("~/projects/huggingface/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 <- 10


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/projects/huggingface/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/projects/huggingface/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

# NOTE: THERE IS AN ERROR HERE.  FOR THE SINGLETONS, THE ID IS THE
# ANNOTATED_FEATURE ID, NOT THE GENOME_MAP_ID
# as_2026 <- arrow::read_parquet("~/projects/huggingface/callingcards/deprecated/2026_analysis_set.parquet")
# annotated_feature_meta <- arrow::read_parquet("~/projects/huggingface/callingcards/annotated_feature_meta.parquet")
# as_2026_singles <- as_2026 |>
#     filter(str_detect(gm_id, "-", negate = TRUE)) |>
#     dplyr::rename(id = gm_id) |>
#     mutate(id = as.numeric(id)) |>
#     left_join(
#         annotated_feature_meta |>
#             dplyr::select(id, gm_id = genome_map_id)
#     ) |>
#     dplyr::relocate(id, gm_id) |>
#     dplyr::select(-id) |>
#     mutate(gm_id = as.character(gm_id))
#
# as_2026_revised <- as_2026 |>
#     filter(str_detect(gm_id, "-")) |>
#     bind_rows(as_2026_singles)
#
# arrow::write_parquet(as_2026_revised, "~/projects/huggingface/callingcards/2026_analysis_set.parquet")
as_2026 <- arrow::read_parquet("~/projects/huggingface/callingcards/2026_analysis_set.parquet")
passing_rep_gm_ids <- unlist(map(unique(as_2026$gm_id), str_split, "-", simplify = TRUE))

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(
            gm_id = 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/projects/huggingface/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(
            gm_id = 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/projects/huggingface/callingcards/annotated_feature_reprocess_start_codon_500bp_analysis.parquet",
            compression = "zstd",
            write_statistics = TRUE,
            use_dictionary = TRUE
        )
} else if (PROMOTERS == "yiming") {
    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(
            gm_id = 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")

    out <- results_combined_analysis_df |>
        ungroup() |>
        dplyr::select(-condition) |>
        arrange(regulator_locus_tag)

    out |>
        arrow::write_parquet(
            "/home/chase/projects/huggingface/callingcards/annotated_feature_reprocess_yiming_analysis.parquet",
            compression = "zstd",
            write_statistics = TRUE,
            use_dictionary = TRUE
        )
} else if (PROMOTERS == "mindel") {
    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(
            gm_id = 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")

    out <- results_combined_analysis_df |>
        ungroup() |>
        dplyr::select(-condition) |>
        arrange(regulator_locus_tag)

    out |>
        arrow::write_parquet(
            "/home/chase/projects/huggingface/callingcards/annotated_feature_reprocess_mindel_analysis.parquet",
            compression = "zstd",
            write_statistics = TRUE,
            use_dictionary = TRUE
        )
}