shell:
    """
    AdapterRemoval \
        --file1 {input.sample} \
        {params.extra} \
        {params.adapters} \
        --threads {threads} \
        --output1 {output.fastq} \
        --discarded /dev/null \
        --settings {output.settings} &> {log}
    """

shell:
    """
    echo -e "Started conversion at $(date)" >> {log}
    bedGraphToBigWig {input.bedgraph} {input.chrom_sizes} {output.bigwig}
    echo -e "Finished conversion at $(date)" >> {log}
    """

shell:
    """
    fastqc \
      {params.extra} \
      -t {threads} \
      --outdir {params.outdir} \
      {input.fq} &> {log}
    """

shell:
    """
    macs2 callpeak \
        -t {input.bam}\
        -c {input.control} \
        -f BAM --bdg --SPMR \
        {params.extra} \
        -n {params.prefix} \
        --outdir {params.outdir} 2> {log}
    cp {log} {output.log}
    """

shell:
    """
    multiqc \
      {params.extra} \
      --force \
      -o {params.outdir} \
      -n multiqc.html \
      {input} 2> {log}
    """

shell:
    """
    TEMPDIR=$(mktemp -d -t samXXXXXXXXXX)
    echo -e "Writing to $TEMPDIR" >>{log}

    samtools view -h {params.view} {input} |\
        samtools sort {params.sort} \
            -@ {threads} -m 4G \
            -T $TEMPDIR \
            -O BAM \
            -o {output} 2>> {log}

    echo -e "Deleting $TEMPDIR" >> {log}
    rm -rf $TEMPDIR
    """

__author__ = "Johannes Köster"
__copyright__ = "Copyright 2016, Johannes Köster"
__email__ = "[email protected]"
__license__ = "MIT"


import os
from snakemake.shell import shell
from snakemake_wrapper_utils.samtools import get_samtools_opts


def get_format(path: str) -> str:
    """
    Return file format since Bowtie2 reads files that
    could be gzip'ed (extension: .gz) or bzip2'ed (extension: .bz2).
    """
    if path.endswith((".gz", ".bz2")):
        return path.split(".")[-2].lower()
    return path.split(".")[-1].lower()


bowtie2_threads = snakemake.threads - 1
if bowtie2_threads < 1:
    raise ValueError(
        f"This wrapper expected at least two threads, got {snakemake.threads}"
    )

# Setting parse_threads to false since samtools performs only
# bam compression. Thus the wrapper would use *twice* the amount
# of threads reserved by user otherwise.
samtools_opts = get_samtools_opts(snakemake, parse_threads=False)

extra = snakemake.params.get("extra", "")
log = snakemake.log_fmt_shell(stdout=True, stderr=True)


n = len(snakemake.input.sample)
assert (
    n == 1 
), "input->sample must have 1 (single-end) element."

reads = ""
if get_format(snakemake.input.sample[0]) in ("bam", "sam"):
    reads = f"-b {snakemake.input.sample[0]}"
else:
    if snakemake.params.get("interleaved", False):
        reads = f"--interleaved {snakemake.input.sample[0]}"
    else:
        reads = f"-U {snakemake.input.sample[0]}"


if all(get_format(sample) in ("fastq", "fq") for sample in snakemake.input.sample):
    extra += " -q "
elif all(get_format(sample) == "tab5" for sample in snakemake.input.sample):
    extra += " --tab5 "
elif all(get_format(sample) == "tab6" for sample in snakemake.input.sample):
    extra += " --tab6 "
elif all(
    get_format(sample) in ("fa", "mfa", "fasta") for sample in snakemake.input.sample
):
    extra += " -f "


metrics = snakemake.output.get("metrics")
if metrics:
    extra += f" --met-file {metrics} "

unaligned = snakemake.output.get("unaligned")
if unaligned:
    extra += f" --un {unaligned} "

unpaired = snakemake.output.get("unpaired")
if unpaired:
    extra += f" --al {unpaired} "

unconcordant = snakemake.output.get("unconcordant")
if unconcordant:
    extra += f" --un-conc {unconcordant} "

concordant = snakemake.output.get("concordant")
if concordant:
    extra += f" --al-conc {concordant} "


index = os.path.commonprefix(snakemake.input.idx).rstrip(".")


shell(
    "(bowtie2"
    " --threads {bowtie2_threads}"
    " {reads} "
    " -x {index}"
    " {extra}"
    "| samtools view --with-header "
    " {samtools_opts}"
    " -"
    ") {log}"
)

conda_pre <- system2("echo", "$CONDA_PREFIX", stdout = TRUE)
if (conda_pre != ""){
  conda_lib_path <- file.path(conda_pre, "lib", "R", "library")
  if (!dir.exists(conda_lib_path)) conda_lib_path <- NULL
  prev_paths <- .libPaths()
  paths_to_set <- unique(c(conda_lib_path, prev_paths))
  .libPaths(paths_to_set)
}

library(tidyverse)
library(yaml)
library(glue)
library(magrittr)

config <- read_yaml(here::here("config", "config.yml"))
samples <- read_tsv(here::here(config$samples))
targets <- sort(unique(samples$target))
dir <- basename(getwd())

site_yaml <- list(
  name = dir,
  output_dir = "../docs",
  navbar = list(
    title = dir,
    left = list(
      list(text = "Home", href = "index.html"),
      list(
        text = "QC", menu = list(
          list(text = "Raw Data", href = "raw_qc.html"),
          list(text = "Trimmed Data", href = "trimmed_qc.html"),
          list(text = "Alignments", href = "align_qc.html")
        )
      ),
      list(
        text = "Results", menu = list()
      )
    ),
    right = list(
      list(icon = "fa-github", href = "https://github.com/smped/prepareChIPs")
    )
  ),
  output = list(
    html_document = list(
      code_folding = "hide",
      toc = TRUE, toc_float = TRUE,
      theme = "sandstone", highlight = "textmate",
      includes = list(after_body = "footer.html")
    )
  )
)


## Create the output directory, if it doesn't exist
if (!is.null(site_yaml$output_dir)) {
  out_dir <- here::here("docs")
  message("Checking for directory: ", out_dir)
  if (!dir.exists(out_dir)) {
    message("Creating: ", out_dir)
    stopifnot(dir.create(out_dir))
  }
  message(out_dir, " exists")
}


site_yaml$navbar$left[[3]]$menu <- lapply(
  targets,
  function(x) {
    list(text = x, href = glue("{x}_macs2_summary.html"))
  }
)

## Create the analysis directory if it doesn't exist
analysis_dir <- here::here("analysis")
if  (!dir.exists(analysis_dir)) dir.create(analysis_dir)
write_yaml(site_yaml, file.path(analysis_dir, "_site.yml"))