
# 1. Crosses - Embryo Rescue
observeEvent(input$tc_labels,{
  dt <- Banana()
  if(input$tc_labels == "CROSSES (EMBRYO RESCUE)"){
    updateSelectInput(session, 'tc_site_1', 'SITE', choices = c(levels(dt$Location)))
  }
})

tc_Er <- reactive({
  dt <- Banana() %>%
    dplyr::select(Location, Crossnumber, Embryo_Rescue_Date, Number_of_Embryo_Rescued) %>%
    dplyr::filter(Number_of_Embryo_Rescued > 0, Embryo_Rescue_Date > "2019-01-01")

  if(input$tc_site_1 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_1)
  }
  dt
})


observeEvent(input$tc_site_1,{
  dt <- tc_Er()
  dt$Embryo_Rescue_Date <- lubridate::ymd(dt$Embryo_Rescue_Date)
  t <- unique(dt$Embryo_Rescue_Date)

  updateDateRangeInput(session, "tcdate_1", "Date Range",
                       start = min(t, na.rm=T), end = max(t, na.rm=T),
                       min = min(t, na.rm=T), max = max(t, na.rm=T))
})

# data
tc_Er1 <- reactive({
  req(input$tcdate_1)

  dt <- tc_Er()
  dt %>%
    dplyr::filter(between(Embryo_Rescue_Date, input$tcdate_1[1], input$tcdate_1[2])) %>%
    dplyr::arrange(desc(Embryo_Rescue_Date))
})


# show
output$copies_1_out <- renderUI({
  if(input$number_per_tube_1 == 'single plant'){
      numericInput("number_of_copies_1", "Number of labels (copies)", value = 1, min = 1, max = 20)
    }
})

observeEvent(input$tc_site_1,{
  id <- as.character(tc_Er1()$Crossnumber)
  updateSelectizeInput(session, "scan_ids_1",  "Scan IDs to show", choices = c('', id), server = TRUE)
})


# scanned ids
tc_Er2 <- reactive({
  if(length(input$scan_ids_1)>0){
    dt <- tc_Er1() %>%
      dplyr::filter(Crossnumber %in% input$scan_ids_1)
  } else {
    dt <- tc_Er1()
  }
  dt
})

# data table

tc_dt_1_input <- reactive({
  if (length(input$scan_ids_1) == 0){
    showFeedbackWarning(inputId = "scan_ids_1", text = "")
  } else {
    hideFeedback("scan_ids_1")
  }
  dt <- tc_Er2()

  dt$Number_of_Embryo_Rescued <- as.numeric(dt$Number_of_Embryo_Rescued)
  colnames(dt) <- gsub("_"," ", names(dt))
  dt
})
output$tc_dt_1 <- DT::renderDataTable(
  tc_dt_1_input(), options = list(pageLength = 10,
                               lengthMenu = c(10, 50, 100, 500,1000),
                               searchHighlight=T,
                               stateSave = TRUE)
)

# download
download_tc_Er <- reactive({
  dt <- tc_Er2()

  # selected rows
  dt <- dt[input[["tc_dt_1_rows_all"]],]
  if(!is.null(input$tc_dt_1_rows_selected)){
    dt <- dt[input$tc_dt_1_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_1 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_1 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_1), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_1 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_of_Embryo_Rescued[i]>3){
        dt$n[i] <- ceiling((dt$Number_of_Embryo_Rescued[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_1 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_of_Embryo_Rescued[i]>6){
        dt$n[i] <- ceiling((dt$Number_of_Embryo_Rescued[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_1 == "Equal to # Embryo Rescued"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Number_of_Embryo_Rescued"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df <- data.frame(stringr::str_split_fixed(dt$Crossnumber,"_",2))
  colnames(df) <- c('Prefix','Suffix')
  df$Suffix <- gsub("[)]","",(gsub("[(]","", df$Suffix)))

  cbind(dt,df) %>%
      dplyr::select(Crossnumber, Prefix, Suffix)
})

# on click download
output$tc_download_1 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_1,"-Embryo Rescue-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_Er(), file)
  }
)


# 2. Embryo Germination

observeEvent(input$tc_labels,{
  dt <- EmbryoGermination()
  if(input$tc_labels == "EMBRYO GERMINATING"){
    updateSelectInput(session, 'tc_site_2', 'SITE', choices = c(levels(dt$Location)))
  }
})

# data
tc_Eg <- reactive({

  if(input$tc_site_2 != ""){
    dt <- EmbryoGermination() %>%
      dplyr::filter(Location %in% input$tc_site_2)
  }else {
    dt <- EmbryoGermination()
  }
  dt %>%
    dplyr::arrange(desc(Germination_Date))
})


observeEvent(input$tc_site_1,{
  dt <- tc_Eg()
# dt$Number_of_Embryo_Germinating <- as.numeric(dt$Number_of_Embryo_Germinating)
  dt$Germination_Date <- lubridate::ymd(dt$Germination_Date)
  t <- unique(dt$Germination_Date)

  updateDateRangeInput(session, "tcdate_2", "Date Range",
                       start = min(t, na.rm=T), end = max(t, na.rm=T),
                       min = min(t, na.rm=T), max = max(t, na.rm=T))
})

tc_Eg1 <- reactive({
  tc_Eg() %>%
    dplyr::filter(between(Germination_Date, input$tcdate_2[1], input$tcdate_2[2])) %>%
    dplyr::arrange(desc(Germination_Date))
})

observeEvent(input$tc_site_2,{
  id <- as.character(tc_Eg1()$PlantletID)
  updateSelectizeInput(session, "scan_ids_2",  "Scan IDs to show", choices = c('', id), server = TRUE)
})

# scanned ids
tc_Eg2 <- reactive({
  if(length(input$scan_ids_2)>0){
    dt <- tc_Eg1() %>%
      dplyr::filter(PlantletID %in% input$scan_ids_2)
  } else {
    dt <- tc_Eg1()
  }
  dt
})

# data table
output$tc_dt_2 <- DT::renderDataTable({
  if (length(input$scan_ids_2) == 0){
    showFeedbackWarning(inputId = "scan_ids_2", text = "")
  } else {
    hideFeedback("scan_ids_2")
  }
    dt <- tc_Eg2()
    colnames(dt) <- gsub("_"," ", names(dt))
    DT::datatable(dt,
                  filter = 'top',
                  rownames = FALSE,
                  escape = FALSE,
                  options = list(pageLength = 10,
                                 lengthMenu = c(10, 50, 100, 500,1000),
                                 searchHighlight=T,
                                 stateSave = TRUE)
    )

})

# download
download_tc_Eg <- reactive({
  dt <- tc_Eg2()

  # selected rows
  dt <- dt[input[["tc_dt_2_rows_all"]],]
  if(!is.null(input$tc_dt_2_rows_selected)){
    dt <- dt[input$tc_dt_2_rows_selected,]
  }

  if(input$number_of_copies_2 > 0){
    dt <- purrr::map_df(seq_len(input$number_of_copies_2), ~dt) %>%
      .[order(.[,1]),]
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo)
})

# on click download
output$tc_download_2 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_2,"-Embryo Germination-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_Eg(), file)
  }
)

# 3. subcultures



observeEvent(input$tc_labels,{
  dt <- Subcultures()
  if(input$tc_labels == "SUBCULTURES"){
    updateSelectInput(session, 'tc_site_3', 'SITE', choices = c(levels(dt$Location)))
  }
})

tc_Sub <- reactive({
  dt <- Subcultures() %>%
    dplyr::select(-Crossnumber)
  if(input$tc_site_3 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_3)
  }
  dt
})

observeEvent(input$tc_site_3,{
  dt <- tc_Sub()

  dt$Subculture_Date <- lubridate::ymd(dt$Subculture_Date)
  t <- unique(dt$Subculture_Date)
  updateDateRangeInput(session, "tcdate_3", "Date Range",
                       start = min(t, na.rm=T), end = max(t, na.rm=T),
                       min = min(t, na.rm=T), max = max(t, na.rm=T))
})

# show
output$copies_3_out <- renderUI({
  if(input$number_per_tube_3 == 'single plant'){
    numericInput("number_of_copies_3", "Number of labels (copies)", value = 1, min = 1, max = 20)
  }
})


# data
tc_Sub1 <- reactive({
  tc_Sub() %>%
    dplyr::filter(between(Subculture_Date, input$tcdate_3[1], input$tcdate_3[2])) %>%
    dplyr::arrange(desc(Subculture_Date))
})

observeEvent(input$tc_site_3,{
  id <- tc_Sub1()$PlantletID
  updateSelectizeInput(session, "scan_ids_3",  "Scan IDs to show", choices = c('', id), server = TRUE)
})


# scanned ids
tc_Sub2 <- reactive({
  dt <- tc_Sub1()
  if(length(input$scan_ids_3)>0){
    dt <- dt %>%
      dplyr::filter(PlantletID %in% input$scan_ids_3)
  }
  dt
})

# data table
output$tc_dt_3 <- DT::renderDataTable({
  if (length(input$scan_ids_3) == 0){
    showFeedbackWarning(inputId = "scan_ids_3", text = "")
  } else {
    hideFeedback("scan_ids_3")
  }
    dt <- tc_Sub2()
    colnames(dt) <- gsub("_"," ", names(dt))

    DT::datatable(dt,
                  filter = 'top',
                  rownames = FALSE,
                  escape = FALSE,
                  options = list(pageLength = 10,
                                 lengthMenu = c(10, 50, 100, 500,1000),
                                 searchHighlight=T,
                                 stateSave = TRUE)
    )
})



# download
download_tc_Sub <- reactive({
  dt <- tc_Sub2()

  # selected rows
  dt <- dt[input[["tc_dt_3_rows_all"]],]
  if(!is.null(input$tc_dt_3_rows_selected)){
    dt <- dt[input$tc_dt_3_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_3 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_3 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_3), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_3 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Copies[i]>3){
        dt$n[i] <- ceiling((dt$Copies[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_3 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Copies[i]>6){
        dt$n[i] <- ceiling((dt$Copies[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_3 == "Equal to # of Copies"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Copies"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo)
})

# on click download
output$tc_download_3 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_3,"-Subcultures-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_Sub(), file)
  }
)

# Rooting

observeEvent(input$tc_labels,{
  dt <- Rooting()
  if(input$tc_labels == "ROOTING"){
    updateSelectInput(session, 'tc_site_4', 'SITE', choices = c(levels(dt$Location)))
  }
})

tc_Root <- reactive({
  dt <- Rooting() %>%
    dplyr::select(-Crossnumber)
  if(input$tc_site_4 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_4)
  }
  dt
})


observeEvent(input$tc_site_4,{
  dt <- tc_Root()

  dt$Date_of_Rooting <- lubridate::ymd(dt$Date_of_Rooting)
  t <- unique(dt$Date_of_Rooting)
  updateDateRangeInput(session, "tcdate_4", "Date Range",
                       start = min(t, na.rm=T), end = max(t, na.rm=T),
                       min = min(t, na.rm=T), max = max(t, na.rm=T))
})

# show
output$copies_4_out <- renderUI({
  if(input$number_per_tube_4 == 'single plant'){
    numericInput("number_of_copies_4", "Number of labels (copies)", value = 1, min = 1, max = 20)
  }
})


# data
tc_Root1 <- reactive({
  dt <- tc_Root()
  dt %>%
    dplyr::filter(between(Date_of_Rooting, input$tcdate_4[1], input$tcdate_4[2])) %>%
    dplyr::arrange(desc(Date_of_Rooting))
})

observeEvent(input$tc_site_4,{
  id <- tc_Root1()$PlantletID
  updateSelectizeInput(session, "scan_ids_4",  "Scan IDs to show",
                       choices = c('', id), server = TRUE)
})


# scanned ids
tc_Root2 <- reactive({
  dt <- tc_Root1()
  if(length(input$scan_ids_4)>0){
    dt <- dt %>%
      dplyr::filter(PlantletID %in% input$scan_ids_4)
  }
  dt
})

# data table
output$tc_dt_4 <- DT::renderDataTable({
  if (length(input$scan_ids_4) == 0){
    showFeedbackWarning(inputId = "scan_ids_4", text = "")
  } else {
    hideFeedback("scan_ids_4")
  }
  dt <- tc_Root2()
  colnames(dt) <- gsub("_"," ", names(dt))

  DT::datatable(dt,
                filter = 'top',
                rownames = FALSE,
                escape = FALSE,
                options = list(pageLength = 10,
                               lengthMenu = c(10, 50, 100, 500,1000),
                               searchHighlight=T,
                               stateSave = TRUE)
  )
})


# download
download_tc_Root <- reactive({
  dt <- tc_Root2()

  # selected rows
  dt <- dt[input[["tc_dt_4_rows_all"]],]
  if(!is.null(input$tc_dt_4_rows_selected)){
    dt <- dt[input$tc_dt_4_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_4 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_4 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_4), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_4 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_Rooting[i]>3){
        dt$n[i] <- ceiling((dt$Number_Rooting[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_4 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_Rooting[i]>6){
        dt$n[i] <- ceiling((dt$Number_Rooting[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_4 == "Equal to # in Rooting"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Number_Rooting"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo, Ploidy_Level)
})

# on click download
output$tc_download_4 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_4,"-Rooting-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_Root(), file)
  }
)

# Weaning 1/ Sending Out

observeEvent(input$tc_labels,{
  dt <- Weaning1()

  if(input$tc_labels == "WEANING 1/ SENDING OUT"){
    updateSelectInput(session, 'tc_site_5', 'SITE', choices = c(levels(dt$Location)))
  }
})

tc_W1 <- reactive({
  dt <- Weaning1() %>%
    dplyr::select(-Crossnumber)

  if(input$tc_site_5 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_5)
  }
  dt
})

observeEvent(input$tc_site_5,{
  dt <- tc_W1()

  dt$Sending_Out_Date <- lubridate::ymd(dt$Sending_Out_Date)
  t <- unique(dt$Sending_Out_Date)
  updateDateRangeInput(session, "tcdate_5", "Date Range",
                       start = min(t, na.rm=T), end = max(t, na.rm=T),
                       min = min(t, na.rm=T), max = max(t, na.rm=T))

})

# show
output$copies_5_out <- renderUI({
  if(input$number_per_tube_5 == 'single plant'){
    numericInput("number_of_copies_5", "Number of labels (copies)", value = 1, min = 1, max = 20)
  }
})


# data
tc_W11 <- reactive({
  dt <- tc_W1()
  dt %>%
    dplyr::filter(between(Sending_Out_Date, input$tcdate_5[1], input$tcdate_5[2])) %>%
    dplyr::arrange(desc(Sending_Out_Date))
})

observeEvent(input$tc_site_5,{
  id <- tc_W11()$PlantletID
  updateSelectizeInput(session, "scan_ids_5",  "Scan IDs to show",
                       choices = c('', id), server = TRUE)

})


# scanned ids
tc_W12 <- reactive({
  dt <- tc_W11()
  if(length(input$scan_ids_5)>0){
    dt <- dt %>%
      dplyr::filter(PlantletID %in% input$scan_ids_5)
  }
  dt
})

# data table
output$tc_dt_5 <- DT::renderDataTable({
  if (length(input$scan_ids_5) == 0){
    showFeedbackWarning(inputId = "scan_ids_5", text = "")
  } else {
    hideFeedback("scan_ids_5")
  }
  dt <- tc_W12()
  colnames(dt) <- gsub("_"," ", names(dt))

  DT::datatable(dt,
                filter = 'top',
                rownames = FALSE,
                escape = FALSE,
                options = list(pageLength = 10,
                               lengthMenu = c(10, 50, 100, 500,1000),
                               searchHighlight=T,
                               stateSave = TRUE)
  )
})


# download
download_tc_W1 <- reactive({
  dt <- tc_W12()

  # selected rows
  dt <- dt[input[["tc_dt_5_rows_all"]],]
  if(!is.null(input$tc_dt_5_rows_selected)){
    dt <- dt[input$tc_dt_5_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_5 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_5 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_5), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_5 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_Sent_Out[i]>3){
        dt$n[i] <- ceiling((dt$Number_Sent_Out[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_5 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_Sent_Out[i]>6){
        dt$n[i] <- ceiling((dt$Number_Sent_Out[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_5 == "Equal to # Sent Out"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Number_Sent_Out"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo, Ploidy_Level)
})

# on click download
output$tc_download_5 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_5,"-Weaning1-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_W1(), file)
  }
)

# Weaning 2

observeEvent(input$tc_labels,{
  dt <- Weaning2()

  if(input$tc_labels == "WEANING 2"){
    updateSelectInput(session, 'tc_site_6', 'SITE',  choices = c(levels(dt$Location)))
  }
})

tc_W2 <- reactive({
  dt <- Weaning2() %>%
    dplyr::select(-Crossnumber)

  if(input$tc_site_6 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_6)
  }
  dt
})

observeEvent(input$tc_site_6,{
  dt <- tc_W2()

  dt$Weaning_2_Date <- lubridate::ymd(dt$Weaning_2_Date)
  t <- unique(dt$Weaning_2_Date)
  updateDateRangeInput(session, "tcdate_6", "Date Range",
                       start = min(t, na.rm=T), end = max(t, na.rm=T),
                       min = min(t, na.rm=T), max = max(t, na.rm=T))
})

# show
output$copies_6_out <- renderUI({
  if(input$number_per_tube_6 == 'single plant'){
    numericInput("number_of_copies_6", "Number of labels (copies)", value = 1, min = 1, max = 20)
  }
})


# data
tc_W21 <- reactive({
  dt <- tc_W2()
# if(input$tcdate_6 !='' | is.na(input$tcdate_6){
dt <- dt %>%
    dplyr::filter(between(Weaning_2_Date, input$tcdate_6[1], input$tcdate_6[2])) %>%
    dplyr::arrange(desc(Weaning_2_Date))
#}
dt
})

observeEvent(input$tc_site_6,{
  id <- tc_W21()$PlantletID
  updateSelectizeInput(session, "scan_ids_6",  "Scan IDs to show",
                       choices = c('', id), server = TRUE)

})


# scanned ids
tc_W22 <- reactive({
  dt <- tc_W21()
  if(length(input$scan_ids_6)>0){
    dt <- dt %>%
      dplyr::filter(PlantletID %in% input$scan_ids_6)
  }
  dt
})

# data table
output$tc_dt_6 <- DT::renderDataTable({
  if (length(input$scan_ids_6) == 0){
    showFeedbackWarning(inputId = "scan_ids_6", text = "")
  } else {
    hideFeedback("scan_ids_6")
  }
  dt <- tc_W22()
  colnames(dt) <- gsub("_"," ", names(dt))

  DT::datatable(dt,
                filter = 'top',
                rownames = FALSE,
                escape = FALSE,
                options = list(pageLength = 10,
                               lengthMenu = c(10, 50, 100, 500,1000),
                               searchHighlight=T,
                               stateSave = TRUE)
  )
})

# download
download_tc_W2 <- reactive({
  dt <- tc_W22()

  # selected rows
  dt <- dt[input[["tc_dt_6_rows_all"]],]
  if(!is.null(input$tc_dt_6_rows_selected)){
    dt <- dt[input$tc_dt_6_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_6 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_6 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_6), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_6 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Weaning_2[i]>3){
        dt$n[i] <- ceiling((dt$Number_in_Weaning_2[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_6 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Weaning_2[i]>6){
        dt$n[i] <- ceiling((dt$Number_in_Weaning_2[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_6 == "Equal to # in Weaning 2"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Number_in_Weaning_2"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo, Ploidy_Level)
})

# on click download
output$tc_download_6 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_6,"-Weaning2-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_W2(), file)
  }
)

# Screenhouse Transfer

observeEvent(input$tc_labels,{
  dt <- Screenhouse()
  if(input$tc_labels == "SCREENHOUSE TRANSFER"){
    updateSelectInput(session, 'tc_site_7', 'SITE', choices = c(levels(dt$Location)))
  }
})

tc_ScrnHs <- reactive({
  dt <- Screenhouse() %>%
    dplyr::select(-Crossnumber)

  if(input$tc_site_7 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_7)
  }
  dt
})


observeEvent(input$tc_site_7,{
  dt <- tc_ScrnHs()
  dt$Screenhouse_Transfer_Date <- lubridate::ymd(dt$Screenhouse_Transfer_Date)
  t <- unique(dt$Screenhouse_Transfer_Date)

  updateDateRangeInput(session, "tcdate_7", "Date Range",
                       start = min(t), end = max(t),
                       min = min(t), max = max)
})

# show
output$copies_7_out <- renderUI({
  if(input$number_per_tube_7 == 'single plant'){
    numericInput("number_of_copies_7", "Number of labels (copies)", value = 1, min = 1, max = 20)
  }
})


# data
tc_ScrnHs1 <- reactive({
  dt <- tc_ScrnHs()
  dt$Screenhouse_Transfer_Date <- lubridate::ymd(dt$Screenhouse_Transfer_Date)

  dt %>%
    dplyr::filter(between(Screenhouse_Transfer_Date, input$tcdate_7[1], input$tcdate_7[2])) %>%
    dplyr::arrange(desc(Screenhouse_Transfer_Date))
})

observeEvent(input$tc_site_7,{
  id <- tc_ScrnHs1()$PlantletID
  updateSelectizeInput(session, "scan_ids_7",  "Scan IDs to show", choices = c('', id), server = TRUE)
})

# scanned ids
tc_ScrnHs2 <- reactive({
  dt <- tc_ScrnHs1()
  if(length(input$scan_ids_7)>0){
    dt <- dt %>%
      dplyr::filter(PlantletID %in% input$scan_ids_7)
  }
  dt
})

# data table
output$tc_dt_7 <- DT::renderDataTable({
  if (length(input$scan_ids_7) == 0){
    showFeedbackWarning(inputId = "scan_ids_7", text = "")
  } else {
    hideFeedback("scan_ids_7")
  }
  dt <- tc_ScrnHs2()
  colnames(dt) <- gsub("_"," ", names(dt))

  DT::datatable(dt,
                filter = 'top',
                rownames = FALSE,
                escape = FALSE,
                options = list(pageLength = 10,
                               lengthMenu = c(10, 50, 100, 500,1000),
                               searchHighlight=T,
                               stateSave = TRUE)
  )
})


# download
download_tc_ScrnHs <- reactive({
  dt <- tc_ScrnHs2()

  # selected rows
  dt <- dt[input[["tc_dt_7_rows_all"]],]
  if(!is.null(input$tc_dt_7_rows_selected)){
    dt <- dt[input$tc_dt_7_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_7 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_7 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_7), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_7 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Screenhouse[i]>3){
        dt$n[i] <- ceiling((dt$Number_in_Screenhouse[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_7 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Screenhouse[i]>6){
        dt$n[i] <- ceiling((dt$Number_in_Screenhouse[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_7 == "Equal to # in Screenhouse"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Number_in_Screenhouse"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo, Ploidy_Level)
})

# on click download
output$tc_download_7 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_7,"-Screenhouse-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_ScrnHs(), file)
  }
)

# Hardening

observeEvent(input$tc_labels,{
  dt <- Hardening()
  if(input$tc_labels == "HARDENING"){
    updateSelectInput(session, 'tc_site_8', 'SITE', choices = c(levels(dt$Location)))
  }
})


tc_Hardn <- reactive({
  dt <- Hardening() %>%
    dplyr::select(-Crossnumber)

  if(input$tc_site_8 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_8)
  }
  dt
})


observeEvent(input$tc_site_8,{
  dt <- tc_Hardn()

  dt$Hardening_Date <- lubridate::ymd(dt$Hardening_Date)
  t <- unique(dt$Hardening_Date)
  updateDateRangeInput(session, "tcdate_8", "Date Range",
                       start = min(t, na.rm=T), end = max(t, na.rm=T),
                       min = min(t, na.rm=T), max = max(t, na.rm=T))
})

# show
output$copies_8_out <- renderUI({
  if(input$number_per_tube_8 == 'single plant'){
    numericInput("number_of_copies_8", "Number of labels (copies)", value = 1, min = 1, max = 20)
  }
})


# data
tc_Hardn1 <- reactive({
  dt <- tc_Hardn()
  dt %>%
    dplyr::filter(between(Hardening_Date, input$tcdate_8[1], input$tcdate_8[2])) %>%
    dplyr::arrange(desc(Hardening_Date))
})

observeEvent(input$tc_site_8,{
  id <- tc_Hardn1()$PlantletID
  updateSelectizeInput(session, "scan_ids_8",  "Scan IDs to show", choices = c('', id), server = TRUE)
})


# scanned ids
tc_Hardn2 <- reactive({
  dt <- tc_Hardn1()
  if(length(input$scan_ids_8)>0){
    dt <- dt %>%
      dplyr::filter(PlantletID %in% input$scan_ids_8)
  }
  dt
})

# data table
output$tc_dt_8 <- DT::renderDataTable({
  if (length(input$scan_ids_8) == 0){
    showFeedbackWarning(inputId = "scan_ids_8", text = "")
  } else {
    hideFeedback("scan_ids_8")
  }
  dt <- tc_Hardn2()
  colnames(dt) <- gsub("_"," ", names(dt))

  DT::datatable(dt,
                filter = 'top',
                rownames = FALSE,
                escape = FALSE,
                options = list(pageLength = 10,
                               lengthMenu = c(10, 50, 100, 500,1000),
                               searchHighlight=T,
                               stateSave = TRUE)
  )
})


# download
download_tc_Hardn <- reactive({
  dt <- tc_Hardn2()

  # selected rows
  dt <- dt[input[["tc_dt_8_rows_all"]],]
  if(!is.null(input$tc_dt_8_rows_selected)){
    dt <- dt[input$tc_dt_8_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_8 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_8 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_8), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_8 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Hardening[i]>3){
        dt$n[i] <- ceiling((dt$Number_in_Hardening[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_8 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Hardening[i]>6){
        dt$n[i] <- ceiling((dt$Number_in_Hardening[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_8 == "Equal to # in Hardening"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Number_in_Hardening"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo, Ploidy_Level)
})

# on click download
output$tc_download_8 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_8,"-Hardening-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_Hardn(), file)
  }
)


# Openfield

observeEvent(input$tc_labels,{
  dt <- Openfield()
  if(input$tc_labels == "OPEN-FIELD"){
    updateSelectInput(session, 'tc_site_9', 'SITE', choices = c(levels(dt$Location)))
  }
})

tc_Op <- reactive({
  dt <- Openfield() %>%
    dplyr::select(-Crossnumber)
  if(input$tc_site_9 != ""){
    dt <- dt %>%
      dplyr::filter(Location %in% input$tc_site_9)
  }
  dt
})

observeEvent(input$tc_site_9,{
  dt <- tc_Op() %>%
    dplyr::mutate(
      Openfield_Transfer_Date = lubridate::ymd(Openfield_Transfer_Date)
    )

  t <- unique(dt$Openfield_Transfer_Date)
  updateDateRangeInput(session, "tcdate_9", "Date Range")
                       # start = min(t), end = max(t),
                       # min = min(t), max = max(t))
})

# show
output$copies_9_out <- renderUI({

  if(input$number_per_tube_9 == 'single plant'){
    numericInput("number_of_copies_9", "Number of labels (copies)", value = 1, min = 1, max = 20)
  }
})


# data
tc_Op1 <- reactive({
  tc_Op() %>%
        dplyr::filter(between(Openfield_Transfer_Date, input$tcdate_9[1], input$tcdate_9[2]))%>%
        dplyr::arrange(desc(Openfield_Transfer_Date))
})

observeEvent(input$tc_site_9,{
  id <- tc_Op1()$PlantletID
  updateSelectizeInput(session, "scan_ids_9",  "Scan IDs to show", choices = c('', id), server = TRUE)
})


# scanned ids
tc_Op2 <- reactive({
  dt <- tc_Op1()
  if(length(input$scan_ids_9)>0){
    dt <- dt %>%
      dplyr::filter(PlantletID %in% input$scan_ids_9)
  }
  dt
})

# data table

output$tc_dt_9 <- DT::renderDataTable({
  if (length(input$scan_ids_9) == 0){
    showFeedbackWarning(inputId = "scan_ids_9", text = "")
  } else {
    hideFeedback("scan_ids_9")
  }
  dt <- tc_Op2()
  colnames(dt) <- gsub("_"," ", names(dt))

  DT::datatable(dt,
                filter = 'top',
                rownames = FALSE,
                escape = FALSE,
                options = list(pageLength = 10,
                               lengthMenu = c(10, 50, 100, 500,1000),
                               searchHighlight=T,
                               stateSave = TRUE)
  )
})

# download
download_tc_Op <- reactive({
  dt <- tc_Op2()

  # selected rows
  dt <- dt[input[["tc_dt_9_rows_all"]],]
  if(!is.null(input$tc_dt_9_rows_selected)){
    dt <- dt[input$tc_dt_9_rows_selected,]
  }

  # single plants labels
  if(input$number_per_tube_9 == 'single plant'){
    dt <- dt

    if(input$number_of_copies_9 > 0){
      dt <- purrr::map_df(seq_len(input$number_of_copies_9), ~dt) %>%
        .[order(.[,1]),]
    }

  } else if(input$number_per_tube_9 == "3 plants/test tube"){
    # calculate labels for 3 plants per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Openfield[i]>3){
        dt$n[i] <- ceiling((dt$Number_in_Openfield[i])/3)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_9 == "6 plants/test tube"){ # labels for 6 labels per test tube
    for(i in 1:nrow(dt)){
      if(dt$Number_in_Openfield[i]>6){
        dt$n[i] <- ceiling((dt$Number_in_Openfield[i])/6)
      } else{
        dt$n[i] <- 1
      }
    }

    dt <- dt %>%
      tidyr::uncount(n)

  } else if(input$number_per_tube_9 == "Equal to # in Openfield"){
    dt <- as.data.frame(dt)[rep(row.names(dt), dt[, "Number_in_Openfield"]),]
    dt <- data.table::setDT(dt)
  }

  # download formats
  df = data.frame(stringr::str_split_fixed(dt$PlantletID,"_",3))
  colnames(df) = c('Prefix','Suffix',"EmbryoNo")
  df$Suffix = gsub("[)]","",(gsub("[(]","", df$Suffix)))
  cbind(dt,df) %>%
    dplyr::select(PlantletID, Prefix, Suffix, EmbryoNo, Ploidy_Level)
})

# on click download
output$tc_download_9 <- downloadHandler(
  filename = function(){
    paste0(input$tc_site_9,"-Openfield-", Sys.Date(),".xls")
  },
  content = function(file) {
    writexl::write_xlsx(download_tc_Op(), file)
  }
)


