main.qmd

---
title: "deseq2-summary"
format: 
  dashboard:
    orientation: rows
    theme:
        - custom.css
    fontsize: .85em
    linestretch: 1
    expandable: false

server: shiny

---


### {.sidebar width="300"} 
```{r setup}
#| context: setup

library(quarto)
library(shiny)
library(dplyr)
library(tibble)
library(tidyverse)
library(shinycssloaders)
library(heatmaply)
library(shinyjs)
library(shiny.fluent)
library(colourpicker)
library(shiny.blueprint)
library(shinyjqui)
library(tidyr)
library(sparkline)
library(ggplot2)
library(scales)
library(ggpubr)
library(shinyWidgets)
library(bslib)
library(flexdashboard)
library(bsicons)
library(DT)
library(reactable)
library(reshape2)
library(reactablefmtr)
library(htmltools)
library(htmlwidgets)
library(tippy)
library(colourpicker)

fileInput("file", label = "Import DESeq2-Final Results", accept = ".txt", width = "100%")
actionButton(inputId="run","Submit")
hr()
uiOutput(outputId = "contrastID")
hr()
br()
uiOutput(outputId = "filtCounts")

br()
br()

uiOutput(outputId = "mat.switch")
uiOutput("fractionT")

targetFile <- read.delim("targetFile.txt", header = T, sep = "\t")
targetFile$norm <- paste0("norm.", targetFile$label)
targetFile$group <- as.factor(targetFile$group)


pca_rds <- readRDS("/Users/fa286/Desktop/5081D/STAR.COUNTS/rawCounts/5081D/5081D_PCA_Matrix_nTop__500.RDS")

# Assosiate Group Levels with Sample_ID ====
fmain = function(group_){
  
  x = list(targetFile %>% filter(group == group_) %>% pull(norm))
  y = group_
  
  names(x) <- paste0("Group: ", y)
  
  return(x)
}


l5 <- list() 
  
for (i in 1:length(levels(targetFile$group))) {

  l5[[i]] <- fmain(group_ = levels(targetFile$group)[i])
    
}

l6 <- lapply(l5, function(x){
  
 x = noquote(paste0("colGroup(name = '", names(x), "', columns =", noquote(paste0(x)) ,")"))
  
})

```


# Results Summary 
<!-- #------------------------------------------------------->

## Row {height="15%"}

```{r ui-valbox1}
#| padding: 0

uiOutput(outputId = "valbox1")
```

```{r ui-valbox2}
#| padding: 0
uiOutput(outputId = "valbox2")
```

```{r ui-valbox3}
#| padding: 0
uiOutput(outputId = "valbox3")

```



## Row {.tabset}


### DESeq2 Results 


```{r ui-uploaded}
#| expandable: TRUE
#DT::dataTableOutput(outputId = "uploaded")
#output$uploaded <- renderUI(withSpinner(reactableOutput(outputId = "uploadedDb3"), type = 1))
uiOutput(outputId = "uploaded")

```


```{r read-in-Uploads}
#| context: server
#| padding: 0


db <- eventReactive(input$run, {
  if (!is.null(input$file$datapath)) {
    read.delim(input$file$datapath, header = T, sep = "\t") 
  } else {
    stop()
  }
})


# Reactive DropDown Menu in Sidebar -- Allows user to choose available DESeq2 Contrasts + All_Comparisons ====
observeEvent(input$run , {
  
  output$contrastID <- renderUI({

    tagList(
        tags$style(type='text/css', ".selectize-dropdown-content {height: 1000px; }"),
        h5("Select DESeq2 Comparison"),
        selectInput(inputId = "pID", label = "", width = 600,
                    choices = c("All_Comparisons", sapply((strsplit(colnames(db())[grep("*.log2FoldChange", x = colnames(db()))], split = "\\.")), 
                                     FUN = function(x){purrr::pluck(x, 1)})),  
                    selected = "All_Comparisons")
      )
    })
  
  }
  
  
)


# Reactive function to parse the nume and denom for a given contrast ====

con.num <- reactive({

  req(input$pID)

  if (input$pID != "All_Comparisons") {

    a = input$pID

    a1 = str_split(a, pattern = "_vs_")[[1]][1]
    a2 = str_split(a, pattern = "_vs_")[[1]][2]
    #

    return(a1)
    
    }

})



con.denom <- reactive({

  req(input$pID)

  if (input$pID != "All_Comparisons") {

    a = input$pID

    a1 = str_split(a, pattern = "_vs_")[[1]][1]
    a2 = str_split(a, pattern = "_vs_")[[1]][2]
    #

    return(a2)
    
    }

})


# Data Subset Reactive Objects:

# 1. Normalized Counts: ====

norm.counts = reactive({
  req(db())
  db() %>% select(gene_id, gene, baseMean, matches("norm")) %>% tibble::column_to_rownames("gene_id") })

# 2. Filtered Norm Counts Based on basemean quantiles: ====

quants <- reactive({
  quantile(db()$baseMean)
})

norm.counts.filtered = reactive({
  
  req(input$min.counts)
  x = norm.counts()
  x %>% filter(baseMean >= quants()[unname(paste0(input$min.counts, "%"))])

  
  
  
})

# 3. SparkLines Setup: ====

normCounts.tab <- reactive({
  
  req(norm.counts.filtered())

  m1 = norm.counts.filtered()  %>% rownames_to_column("GENE") 
  
  m2 = m1 %>% select(-baseMean, -gene) %>% melt()

  m3 = m2 %>% group_by(GENE) %>% summarise(Trend = list(value))
  
  m4 = left_join(m1, m3, by = c("GENE")) %>% column_to_rownames("GENE")
 
  return(m4)
  
})

# 4. db2 -- comparison selector:====

observeEvent(input$pID,

             if (input$pID =="All_Comparisons") {
               output$mat.switch <- renderUI({tagList(
                      hr(),
                      #materialSwitch(inputId = "switch2",label = "", value = FALSE, status = "warning")
                      )})
             } else if (input$pID != "All_Comparisons") {
                output$mat.switch <- renderUI({tagList(
                      p("Please use this toggle button to switch the numerator and denominator for the selected comparison. "),
                      materialSwitch(inputId = "switch2",label = "Swap Numerator/Denominator", value = FALSE, status = "warning"),
                      p("For the selected comparison:"), 
                      # p(paste0("Numerator Group = ", strsplit(input$pID, split = "_")[[1]][1])),
                      # p(paste0("Denominator/Baseline Group = ", strsplit(input$pID, split = "_")[[1]][3])),   
                      # 
                      # p(paste0("Numerator Group = ")),
                      # p(paste0("Denominator/Baseline Group = "))
                    

                      
                      
                      )
                  
                      })
             }

)

# 4.1 db2 ====
db2 <- reactive({
  req(input$file$datapath)
  req(input$pID)
  req(db())
  
  
  if (input$pID == "All_Comparisons") {
    db() %>% rowwise() %>% mutate(n_comparisons_sig = sum(c_across(matches("padj")) <= 0.05, na.rm = T)) %>%
      select(!matches("norm")) %>% filter(gene_id %in% rownames(norm.counts.filtered())) %>% 
      mutate(Significance = ifelse(n_comparisons_sig == 0, "ns", "Yes")) %>% select(-n_comparisons_sig) %>% 
      select(Significance, everything())
    
  } else if (input$pID !="All_Comparisons"){
    
    a = db() %>% 
          select(gene_id, gene, locus, strand, gene_biotype, matches(input$pID)) 

    b = a %>% rowwise() %>% mutate(n_comparisons_sig = sum(c_across(matches("padj")) <= 0.05, na.rm = T)) %>%
          filter(gene_id %in% rownames(norm.counts.filtered())) %>%
          mutate(Significance = ifelse(n_comparisons_sig == 0, "ns", "Yes")) %>% select(-n_comparisons_sig) %>% 
          select(Significance, everything())
    
    b

  }
  
})

# 4.1.2 db3 ====
db3 <- reactive({
  
  req(db2())
  
  if (is.null(input$switch2)) {
    
    db2()
  
    } else if (input$switch2 == TRUE){
    
    db2() %>% filter(gene_id %in% rownames(norm.counts.filtered())) %>% mutate(across(matches("log2FoldChange"), ~ . * -1))
      
    }  else {
    
      db2()
  }
  
  
})

with_tooltip <- function(value, tooltip, ...) {
  div(style = "text-decoration: underline; cursor: help",
      tippy(value, tooltip, ...))
}

output$uploadedDb3 <- renderReactable(reactable(db3() %>% mutate_if(is.numeric, round, 3), 
                                                resizable = T, striped = T, searchable = T, filterable = F, 
          defaultPageSize = 50, showPageInfo = T, bordered = T, highlight = T,compact = T,
          columns = list(
            gene = colDef( filterable = T),
            strand = colDef(minWidth = 100),
            
            Significance = colDef(minWidth = 100,
              cell = function(value) {
                    if (value == "Yes") {
                      classes <- "tag num-high"
                    } else if (value == "ns") {
                      classes <- "tag num-med"
                    } else {
                      classes <- "tag num-low"
                    }
                    value <- format(value, nsmall = 1)
                    span(class = classes, value)
              }, header = with_tooltip("Significance", "When All_Comparisons is selected, 
                                       Significance Column displays Yes 
                                       where a given row/gene is significant in at least 1 comparison")
            )
        
            
          ),
          width = 1920, defaultColDef = colDef(minWidth = 200, maxWidth = 500, align = "center"), 
          theme = 
            reactableTheme(
                    borderColor    = "#c7c7c7",
                    stripedColor   = "#f6f8fa",
                    highlightColor = "#eddcd8",
                    cellPadding = "8px 12px",
                    style = list(
                      fontFamily = "-apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial, sans-serif"
                    ),
                    searchInputStyle = list(width = "100%"))
          
          
          ))

output$uploaded <- renderUI(withSpinner(reactableOutput(outputId = "uploadedDb3"), type = 1))



# output$uploaded <- DT::renderDataTable(DT::datatable(db3() %>% mutate_if(is.numeric, round, 3),
#                                                      list(paging=T,pageLength = 100, scrollX=T,scrollY=900,
#                                                           autoWidth = F), filter = "none",
#                                                      rownames = T, caption = "DESeq2 Results"))
# 


# Reactive Switch Behavior Num/Denom ====
observeEvent(input$switch2,{
  if (input$switch2 == TRUE && input$pID != "All_Comparisons" && !is.null(input$switch2)) {
    
    frac <- reactive({
     req(con.num())  
     a = c("Numerator", "Denominator/Baseline")
     b = c(con.denom(), con.num())
     data.frame(a,b)
    })
    
    output$fractionT <- renderUI(reactableOutput(outputId = "myT"))

    output$myT <- renderReactable({
    reactable(frac(), searchable = F, columns = list(a = colDef(maxWidth = 150, name = ""), 
                                                     b = colDef(maxWidth = 150, name = "", 
                                                              style = function(value){list(background = "#c9ada7", fontWeight = "bold")},
                                                              cell = function(value){span(class = "myCLASS1", value)})),
                                          columnGroups = list(colGroup(name = "log2FC", columns = c("a", "b"))),
                                          sortable = F, striped = F, outlined = T , resizable = T, bordered = F, highlight = T)
  })
    
  } else if(input$switch2 == FALSE && input$pID != "All_Comparisons" &&  !is.null(input$switch2)){
    
    frac <- reactive({
     req(con.num())  
     a = c("Numerator", "Denominator/Baseline")
     b = c(con.num(), con.denom())
     data.frame(a,b)
    })
    
    output$fractionT <- renderUI(reactableOutput(outputId = "myT"))

    output$myT <- renderReactable({
    reactable(frac(), searchable = F, columns = list(a = colDef(maxWidth = 150, name = ""), 
                                                     b = colDef(maxWidth = 150, name = "",
                                                    style = function(value){list(background = "#C7C7C7", fontWeight = "bold")})),
              columnGroups = list(colGroup(name = "log2FC", columns = c("a", "b"))),
                                                     sortable = T, resizable = T, bordered = F, striped = T, highlight = T)
  })
  }
})








# output$nCountsDT <- DT::renderDT(DT::datatable(normCounts.tab() %>% select(Trend, everything()), list(paging=T,
#                                                                              pageLength = 100, 
#                                                                              scrollX=T, 
#                                                                              scrollY=900,
#                                                                              scrollCollapse = TRUE,
#                                                                              autoWidth = F, dom = 'lftip',
#                                                                              fnDrawCallback = htmlwidgets::JS(
#                                                                               '
#                                                                               function(){
#                                                                                 HTMLWidgets.staticRender();
#                                                                               }
#                                                                               ')), 
#                                                       filter = "none", rownames = T, 
#                                                       caption = "DESeq2 Normalized Counts", 
#                                                       escape = F) %>% spk_add_deps() ) 

# output$nCountsDT <- renderReactable(reactable(normCounts.tab() %>% select(Trend, everything()),
#           columns = list(
#             Trend = colDef(cell =react_sparkline(normCounts.tab(), 
#                                                  line_curve = "linear",
#                                                  decimals = 1,
#                                                  show_area = T,
                                                
#                                                  highlight_points = highlight_points(first="orange",last="blue")), minWidth = 100)
#           ), 
#           resizable = T, striped = F, searchable = T, filterable = F, 
#           defaultPageSize = 50, showPageInfo = T, bordered = T, highlight = T,compact = T,
#           columnGroups = lapply(l6, function(x){eval(parse(text = x))})
# ))




# html_code <- '
#   setInterval(function(){
#     $(".inlinesparkline").sparkline();
#     $(".inlinesparkline").toggleClass("inlinesparkline noinlinesparkline");
#   }, 50);
# '

# Reactive Normalized Counts Table with Sparklines ====
tbl <- reactive({ 
  
  req(normCounts.tab())
  
  tb <-
  reactable(normCounts.tab() %>% select(Trend, everything()),
          columns = list(
            Trend = colDef(
              html = TRUE,
              cell = function(value, index){
                sparkline(normCounts.tab()$Trend[[index]], width = 70, height = 20)
              }, align = "center", maxWidth = 100
            
                )
            
          ), 
          resizable = T, striped = T, searchable = T, filterable = F, 
          defaultPageSize = 50, showPageInfo = T, bordered = T, highlight = T,compact = T,
          columnGroups = lapply(l6, function(x){eval(parse(text = x))}),
          width = 1920, 
          theme = 
            reactableTheme(
                    borderColor = "#c7c7c7",
                    stripedColor = "#f6f8fa",
                    highlightColor = "#eddcd8",
                    cellPadding = "8px 12px",
                    style = list(
                      fontFamily = "-apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial, sans-serif"
                    ),
                    searchInputStyle = list(width = "100%"))
) 
  # adding a custom JavaScript function to render the sparklines from the html tags
  # once the sparkline is created, the class is changed from inlinesparkline to noinlinesparkline
  # changing the class is necessary because otherwise another rendering would remove the created sparkoines
  # this function is run each 20ms so that it is applied even to sparklines on other pages of the reactable

#   normCounts.tab() %>%
#   rowwise() %>%
#   mutate(
#     # preparing the sparklines html manually
#     # sparklines html looks like this <span class="inlinesparkline">1,2,3,4,5</span>
#     Trend = Trend %>%
#       unlist() %>%
#       paste(collapse = ",") %>%
#       paste0('<span class="inlinesparkline">', ., '</span>')
#   ) %>%
#   reactable(
#     columns = list(
#       Trend = colDef(html = T) # rendering the content as html
#     ), 
#     columnGroups = lapply(l6, function(x){eval(parse(text = x))}), borderless = F, bordered = T, striped = F, resizable = T,compact = T,
#     highlight = T,height = 1240, outlined = T,
#     defaultColDef = colDef(minWidth = 10)
  # ) %>%
  # # adding a custom JavaScript function to render the sparklines from the html tags
  # # once the sparkline is created, the class is changed from inlinesparkline to noinlinesparkline
  # # changing the class is necessary because otherwise another rendering would remove the created sparkoines
  # # this function is run each 20ms so that it is applied even to sparklines on other pages of the reactable
  # prependContent(onStaticRenderComplete(
  #   HTML("setInterval(function(){ 
  #           $('.inlinesparkline').sparkline();
  #           $('.inlinesparkline').toggleClass('inlinesparkline noinlinesparkline');
  #         }, 50);
  #        ")
  # ))


# tb$dependencies <- getDependency("sparklines") 
tb

})



output$nCountsDT <- renderReactable({ 
  tbl()
  })




# Reactive Caption for ValBox 3 ====
cap <- reactive({
    req(input$pID)
    req(db2())
    if (input$pID == "All_Comparisons" && !is.null(input$pID)) {
      
      cap = paste0(length(sapply((strsplit(colnames(db())[grep("*.log2FoldChange", x = colnames(db()))], split = "\\.")), 
                                     FUN = function(x){purrr::pluck(x, 1)})), ";DESeq2 contrasts available in this experiment")
    } else {
    
      cap = paste0(length(which(db2() %>% select(matches(".padj")) < 0.05)), ";Differentially Expressed Features Found at padj < 0.05 for ", input$pID)
  }
  
  cap
  
})



# Value Boxes ====
output$valbox1 <- renderUI({
  validate(need(input$file, message = "  
    Please Upload DESeq2 results distributed by TREx and Click Submit!"))
  validate(need(db(), label = "Checks for the presence of db reactable"))
  value_box(title = "Total Annotated Features", value = textOutput(outputId = "v1"), 
            showcase = bs_icon("receipt"), 
            theme = value_box_theme(bg = "#4a4e69"), 
            class = "text-light", showcase_layout = "top right")
})

output$valbox2 <- renderUI({
  validate(need(input$file, message = ""))
  validate(need(db(), label = "Checks for the presence of db reactable"))
  total.filtered <- nrow(norm.counts.filtered())

  value_box(title = paste0("Features remaining with ", input$min.counts, "% quantile filtering" ),
            value =total.filtered, 
            showcase = bs_icon("funnel"), 
            theme = value_box_theme(bg = "#9a8c98"), 
            class = "text-light", showcase_layout = "top right")
})


output$valbox3 <- renderUI({
  validate(need(input$file, message = ""))
  validate(need(db(), label = "Checks for the presence of db reactable"))
  value_box(title =  strsplit(cap(), split = ";")[[1]][2], 
            value = strsplit(cap(), split = ";")[[1]][1], icon = "fa-dna", color = "#c9ada7", caption = strsplit(cap(), split = ";")[[1]][2], 
            showcase = bs_icon("arrow-down-up"), 
            theme = value_box_theme(bg = "#c9ada7"), 
            class = "text-light", showcase_layout = "top right")
})

output$v1 <- renderText(nrow(db()))
# output$v2 <- renderText(nrow(db()))
# output$v3 <- renderText(nrow(db()))





# output$norm.counts.raw <- DT::renderDataTable(DT::datatable(norm.counts() %>% mutate_if(is.numeric, round, 3), 
#                                                      list(paging=T,pageLength = 100, scrollX=T,scrollY=900, 
#                                                           autoWidth = F), filter = "none", 
#                                                      rownames = T, caption = "DESeq2 Normalized Counts")) 
# 
# output$norm.counts.filtered <- DT::renderDataTable(DT::datatable(norm.counts.filtered() %>% mutate_if(is.numeric, round, 3), 
#                                                      list(paging=T,pageLength = 100, scrollX=T,scrollY=900, 
#                                                           autoWidth = F), filter = "none", 
#                                                      rownames = T, caption = "DESeq2 Normalized Filtered Counts")) 

# Slider Filter for baseMean filtering on NormCounts + ggdensity vertical ====
observeEvent(input$run, {

  if (!is.null(input$file$datapath)) {
      output$filtCounts <- renderUI({
    
    tagList(
      tags$style(HTML(".js-irs-0 .irs-single, .js-irs-0 .irs-bar-edge, .js-irs-0 .irs-bar {background: #4a4e69}")),
       h5("Filter Counts"),
       p("Use the slider to filter rows i.e. genes/features based on quantiles of baseMean."),
       sliderInput(inputId = "min.counts", label = "Select min quantile", min = 0, max = 75,
                   value =  25, width = "75%", step = 25),
       hr()
      )
    })
  } else{
    return(NULL)
  }
  }
)

# ui-normalized-counts-w/sparkline ====
output$spinnerSpark <- renderUI(withSpinner(reactableOutput(outputId = "nCountsDT"), type = 1))


norm.stack <- reactive({
  x <- stack(norm.counts() %>% select(-baseMean,-gene))
  colnames(x) <- c("Counts", "Sample")
  return(x)
})

# DensityPlot ====
output$dist.plot <- 
    renderPlotly(
      ggplotly(ggdensity(norm.stack(), x = "Counts",
          rug = F,
          color = "Sample", fill = "Sample", alpha = 0.1, title = "Density Distribution of Normalized Counts") + 
            scale_x_log10() + theme_gray()  + geom_vline(xintercept= input$min.counts, linetype = "dashed") +
            theme(legend.position = "right"), tooltip = c("colour"))
          )

output$DENS <- renderUI(withSpinner(jqui_resizable((plotlyOutput(outputId = "dist.plot", width = 1000, height = 800)))))


# MA-Plot ====
maplot <- reactive({
  validate(need(input$pID !="All_Comparisons", message = "Please Select a DESeq2 Comparison", label = "---"))
  req(input$pID)
  
  if (input$pID != "All_Comparisons" && !is.null(input$switch2) && input$switch2 == FALSE) {
    main = input$pID
    maplot.data = db() %>% select(gene_id, baseMean, matches(input$pID))
    colnames(maplot.data) <-  gsub(pattern = paste0(input$pID,"."), replacement = "", x = colnames((maplot.data)))
    return(list(main = main, maplot.data = maplot.data))
    
    #return(maplot.data)
  } else if (input$pID != "All_Comparisons" && !is.null(input$switch2) && input$switch2 == TRUE){
    
    main = input$pID
    mainA = strsplit(input$pID, split = "_vs_")[[1]][1]
    mainB = strsplit(input$pID, split = "_vs_")[[1]][2]
    main2 = paste0(mainB, "_vs_", mainA)
    
    maplot.data = db() %>% select(gene_id, baseMean, matches(input$pID))
    colnames(maplot.data) <-  gsub(pattern = paste0(input$pID,"."), replacement = "", x = colnames((maplot.data)))
    maplot.data = maplot.data %>% mutate(across(matches("log2FoldChange"), ~ . * -1))
    return(list(main = main2, maplot.data = maplot.data))
  }
  
  
  
  
})


ma <- reactive({

    req(maplot())
    req(input$pID)

      ggmaplot(maplot()[[2]] , main = maplot()[[1]],
         fdr = 0.05, fc = 2, size = 4,
         palette = c("#B31B21", "#1465AC", "darkgray"),
         genenames = as.vector(maplot()[[2]]$gene_id),
         legend = "top", top = 20,
         font.label = c("bold", 14),
         font.legend = "bold",
         font.main = "bold",
         ggtheme = ggplot2::theme_minimal()) +
    theme(
    text = element_text(size = 16),  # Adjust the font size here
    plot.title = element_text(size = 20, face = "bold"),  # Customize title font size
    axis.title = element_text(size = 18),  # Customize axis title font size
    axis.text = element_text(size = 18)  # Customize axis label font size
)

})

output$ma.plot <- renderPlot({
    ma()
})

output$downloadCSV <- downloadHandler(
    filename = function() {
      paste0("Quantile_", input$min.counts, "_Filtered_Normalized_Counts_", Sys.Date(), ".csv", sep="")
    },
    content = function(file) {
      write.csv(normCounts.tab() %>% select(-Trend), file)
    }
    
)

observeEvent(!is.null(norm.counts.filtered()), {
  
  output$csv <- renderUI(downloadButton("downloadCSV", "Download Filtered Normalized Counts", style="width:100%;"))
})



output$maDownload <- downloadHandler(
    filename = function() {
      paste0("MA-Plot_", input$pID, "_", Sys.Date(), ".png", sep="")
    },
    content = function(file) {
      ggsave(file, ma(), bg = "white", width = 10, height = 10, units = "in", dpi = "print")
    }
    
)

# ui-maDownload ===
observeEvent(!is.null(db()), {
  output$ma.button <- renderUI(downloadButton("maDownload", "Download MA-Plot", style="width:100%;"))
})


# ui-MAPlot ====
output$MA <- renderUI(withSpinner(jqui_resizable(jqui_draggable(plotOutput(outputId = "ma.plot", width = 1080, height = 1080)))))



# pca_rds ====
pca.df <- pca_rds$PCA.df

pca_rotation <- pca_rds$prcomp.out$rotation

loading_scores <- data.frame(pca_rotation[,1:5])
ab.loading_scores <- abs(loading_scores)

# pca_loadings ====
output$loadings <- renderReactable(reactable(ab.loading_scores %>% mutate_if(is.numeric, round, 3), 
                          resizable = T, striped = T, searchable = T, filterable = F, 
                          defaultPageSize = 100, showPageInfo = T, bordered = T, highlight = T,compact = F, 
                          defaultSorted = c("PC1"),
                          showSortable = T,
                          columns = list(PC1 = colDef(defaultSortOrder = "desc", sortable = T, 
                                                      header = with_tooltip("PC1", "Higher Loading Score indicates more contribution from the feature/gene"),
                                                      class = function(value, index, name){
                                                        "class-sorted"
                                                      }
                                                      )
                                         
                          ),
                          width = 1200, defaultColDef = colDef(minWidth = 150, maxWidth = 500, align = "left"), 
                          theme = 
                            reactableTheme(
                              borderColor    = "#c7c7c7",
                              stripedColor   = "#f6f8fa",
                              highlightColor = "#eddcd8",
                              cellPadding = "8px 12px",
                              style = list(
                                fontFamily = "-apple-system, BlinkMacSystemFont, Segoe UI, Helvetica, Arial, sans-serif"
                              ),
                              searchInputStyle = list(width = "100%"))
                          
                          
))


output$pcaLoadings <- renderUI(reactableOutput(outputId = "loadings"))

 # render-ui -- cluster  ---------------------------------------------------------------
  
  output$metaID <- renderUI({
    
    
    tagList(
      selectInput(inputId = "metaclusterID", label = "Select Metadata",
                  choices = colnames(pca.df %>% select(!matches("PC"))), selected = "group")
      
    )
    
  })
  
  

  
  # render-ui -- pcx --------------------------------------------------------
  
  output$pcx <- renderUI({
    
    u_sel_meta = req(input$metaclusterID)
    
    tagList(
      selectInput(inputId = "pcx_ID", label = "Select PC of x-axis",
                  choices = colnames(pca.df %>% select(matches("PC"))), selected = "PC1"))
    
    
  })
  
  # render-ui -- pcy --------------------------------------------------------
  
  output$pcy <- renderUI({
    
    u_sel_meta = req(input$metaclusterID)
    
    tagList(
      selectInput(inputId = "pcy_ID", label = "Select PC of y-axis",
                  choices = colnames(pca.df %>% select(matches("PC"))), selected = "PC2"))
    
    
  })
  
  
  # render-ui -- pcz --------------------------------------------------------
  
  output$pcz <- renderUI({
    
    u_sel_meta = req(input$metaclusterID)
    
    tagList(
      selectInput(inputId = "pcz_ID", label = "Select PC of z-axis",
                  choices = colnames(pca.df %>% select(matches("PC"))), selected = "PC3"))
    
    
  })
  

# pca 3d Plotly ====
output$pca3d <- 
    
    renderPlotly({
      
      u_sel_pcx  =  req(input$pcx_ID)
      u_sel_pcy = req(input$pcy_ID)
      u_sel_pcz = req(input$pcz_ID)
      
      # --------------------------------------------------------------------------------------------------------

      m <- list(
        l = 1,
        r = 1,
        b = 50,
        t = 50,
        pad = 1
      )
      plot_ly(data = pca.df,  x = ~  get(u_sel_pcx), y= ~ get(u_sel_pcy), z = ~  get(u_sel_pcz), 
              width = 1800, height = 1200,
              color = ~ get(input$metaclusterID),
              colors = c('#636EFA','#EF553B','#00CC96'),
              text = pca.df$label,
              marker = list(size = 14,
                            line = list(color = ~   get(input$metaclusterID) , width = 1)),
              hovertemplate = paste("<b>%{text}<b><br> PCx: %{x}<br> PCy: %{y}<br> PCz: %{z}")) %>%
        add_markers() %>%
        layout(autosize = T, margin =m, title = "3D Principal Components Analysis",
               scene = list(xaxis = list(title = paste0(input$pcx_ID, ": ", (pca_rds$Variance.df %>% filter(x == input$pcx_ID) %>% pull(percentVar)), " %")),
                            yaxis = list(title = paste0(input$pcy_ID, ": ", (pca_rds$Variance.df %>% filter(x == input$pcy_ID) %>% pull(percentVar)), " %")),
                            zaxis = list(title = paste0(input$pcz_ID, ": ", (pca_rds$Variance.df %>% filter(x == input$pcz_ID) %>% pull(percentVar)), " %"))
               ), margin = m
        ) %>% layout(legend = list(orientation = 'v', xanchor = "left"))
      
      
      
      
      
      
      
    })

output$PCA3 <- renderUI(withSpinner((plotlyOutput(outputId = "pca3d", width = 800, height = 800))))





# Heatmaps ==== 


#req(normCounts.tab())



output$heatmap.options <- renderUI({
  
      tagList(
        tags$style(type='text/css', ".selectize-dropdown-content {height: 1000px; }"),
        h5("Heatmap Options"),
        hr(),
        
        selectInput(inputId = "select", choices = colnames(normCounts.tab() %>% select(matches("norm"))) , multiple = T, label = "Select Samples to discard"),
        
        br(),
        hr(),
        h6("Adjust Colors"),
        colourInput("high", value = "red", label = "High", width = 100),
        colourInput("low", value = "blue", label = "Low", width = 100),
        br(),
        hr(),
        
        
        h6("Adjust Clustering"),
        br(),
        selectInput(inputId = "hm-dend", label = "Dendrogram", choices = c("row", "column", "none", "both"), selected = "none", multiple = F),
        br(),
        
        selectInput(inputId = "hm-cluster", label = "Clustering Distance Method", choices = c("pearson", "spearman", "kendall"), selected = "pearson", multiple = F),
      )
  
  })

# my_palette <- reactive({colorRampPalette(c(z.low(),z.mid(),z.high()))(n = 100)})
my_palette <- colorRampPalette(c("blue", "white","red"))(n = 100)


#output$hmap <- renderUI(withSpinner(jqui_resizable(plotlyOutput("heatmap.render", width = plot.w(), height = plot.h()))))

output$hmap <- renderUI(withSpinner(jqui_resizable(plotlyOutput("heatmap.render", width = 1080, height = 1080))))

output$heatmap.render <-
  renderPlotly({
          heatmaply(x = normCounts.tab()[5:100,] %>% select(-Trend, -gene, -baseMean),
                    Rowv = T,
                    Colv = NULL,
                    scale = "row",
                    dendrogram = "row",
                    colors = my_palette,
                    column_text_angle = 270,
                    xlab = "Samples",
                    ylab = "Core-Enriched Genes",
                    grid_gap = 0.5,
                    hide_colorbar = F,
                    fontsize_row = 12,
                    fontsize_col = 12,
                    margins = c(60,100,40,20),
                    grid_color = "white", plot_method = "plotly", grid_size = 1,
                    distfun = "pearson", col_side_colors = targetFile$group
                    
          ) 




    })



```


### Normalized Counts


```{r ui-NormCountsFinal}
#| expandable: true
uiOutput(outputId = "spinnerSpark")

```

#### {.toolbar}
```{r ui-NormCounts_Download}
uiOutput(outputId = "csv")
```



### Density Distributions 


```{r ui-DensityPlot}
#| expandable: true

uiOutput(outputId = "DENS")

```

### MA-Plot

```{r}
#| expandable: true
uiOutput(outputId = "MA")

```

#### {.toolbar}
```{r ui-MAPlot-Button}
uiOutput(outputId = "ma.button")

```


# PCA-Explorer




## Row {.tabset}


### PCA Plot 


```{r ui-PCA-Plotly}
#| expandable: true
#| padding: 10
#| width: 60%

uiOutput(outputId = "PCA3")

```

#### {.sidebar width="300"}
```{r}
#| expandable: true
#| padding: 10

shinycssloaders::withSpinner(uiOutput("metaID"), type = 1)
uiOutput("pcx")
uiOutput("pcy")
uiOutput("pcz")

```


### PCA Variance 



```{r ui-pca-Loadings}
#| title: "Loading Scores for Top 500 Genes"
#| expandable: true
#| padding: 10


uiOutput("pcaLoadings")


```


# Heatmapper


## Row 

### PCA Plot 


```{r}
#| expandable: true
#| padding: 10
#| width: 60%

uiOutput("hmap")

```

### {.sidebar width="400"}
```{r}
#| expandable: true
#| padding: 10

uiOutput("heatmap.options")

```