function(input, output, session) {
  
  #output$LogoPlotSnps = renderPlot(LogoPlotSnps(mutable_df3))
  output$lin_sc = renderPlot(
    lin_sc(
      input$switch_target,
      all_lineages = input$all_lineages,
      my_xats = 12, # x axis text size
      my_yats = 12, # y axis text size
      my_xals = 12, # x axis label size
      my_yals = 12, # y axis label size
      my_lls   = 12, # legend label size
      d_lab_size = 4
    )
  )
  #### lineage_distP ####
  output$lineage_distP = renderPlot(
    lineage_distP(
      get(paste0(input$switch_target, '_merged_df2')), 
      all_lineages = input$all_lineages,
      x_lab = "Average Stability",
      x_axis = "avg_stability_scaled",
      fill_categ_cols = c("red", "blue")
    )
  )
  
  
  #### observeEvent() Fun(tm) ####
  observeEvent(
    {
      input$clear_ngl
      input$force
      }, {
    NGLVieweR_proxy("structure") %>%
      removeSelection("Pos")
  })
  # Button to test adding a position
  observeEvent(input$test_ngl, {
    NGLVieweR_proxy("structure") %>%
      addSelection('ball+stick'
                   , param = list(
                     name = "Pos"
                     , sele = "35"
                     , color = "green")
      )
  })
  observeEvent(
    {
      input$force
      input$switch_target
      input$snp_ligand_dist
      input$snp_nca_dist
      input$snp_interface_dist
    },{
      merged_df3 = cbind(get(paste0(input$switch_target, '_merged_df3')))
      
      position_max=max(merged_df3[['position']])
      position_min=min(merged_df3[['position']])
      min_ligand_distance=min(merged_df3$ligand_distance)
      max_ligand_distance=max(merged_df3$ligand_distance)
      # FIXME: these are IMPORTANT
      # # add "pos_count" position count column
      # merged_df3=merged_df3 %>% dplyr::add_count(position)
      # merged_df3$pos_count=merged_df3$n
      # merged_df3$n=NULL
      # 
      mutable_df3 = cbind(merged_df3)
      
      #### site_snp_count_bp ####
      #mutable_df3[(mutable_df3$position>=plot_min & mutable_df3$position <=plot_max),]
      # ligand_distance
      # interface_dist
      # nca_distance
      # change to: multiple plots, all use site_snp_count_bp
      # 4 x plots side by side, one normal (no dist. filter), 2/3 filtered by distance columns above
      # use "subtitle text" from pos_count_bp_i.R
      
      # different data ranges required for SNP distances
      snp_ligand_dist_df3    = merged_df3[merged_df3[['ligand_distance']]<input$snp_ligand_dist,]
      if ("interface_dist" %in% colnames(merged_df3)){
        snp_interface_dist_df3 = merged_df3[merged_df3[['interface_dist']]<input$snp_interface_dist,]
      } else {
        snp_interface_dist_df3 = NULL
      }
      
      if ("nca_distance" %in% colnames(merged_df3)){
        snp_nca_dist_df3       = merged_df3[merged_df3[['nca_distance']]<input$snp_nca_dist,]
      } else {
        snp_nca_dist_df3 = NULL
      }
      
      
      output$site_snp_count_bp = renderPlot(
        site_snp_count_bp(
          mutable_df3,
          title_colour = 'black',
          subtitle_colour = "black",
          leg_text_size = 12,
          axis_label_size = 12,
          geom_ls = 4
        )
      )
      output$site_snp_count_bp_ligand = renderPlot(
        site_snp_count_bp(
          snp_ligand_dist_df3,
          title_colour = 'black',
          subtitle_colour = "black",
          leg_text_size = 12,
          axis_label_size = 12,
          geom_ls = 4
        )
      )
      
      # if ("interface_dist" %in% colnames(input$switch_target)) {
      output$site_snp_count_interface = renderPlot(
        site_snp_count_bp(
          snp_interface_dist_df3,
          title_colour = 'black',
          subtitle_colour = "black",
          leg_text_size = 12,
          axis_label_size = 12,
          geom_ls = 4
        )
      )
      # } #else {
      #   output$site_snp_count_interface = renderPlot(
      #     ggplot() + annotate(x=1,y=1,"text", label="No interface data for this target")+theme_void()
      #   )
      # }
      
      output$site_snp_count_nca = renderPlot( #{
        #if ("nca_distance" %in% colnames(input$switch_target)) {
        site_snp_count_bp(
          snp_nca_dist_df3,
          title_colour = 'black',
          subtitle_colour = "black",
          leg_text_size = 12,
          axis_label_size = 12,
          geom_ls = 4
        )
        #   }  else {
        #     ggplot() + annotate(x=1,y=1,"text", label="No RNA data for this target")+theme_void()
        #   }
        # }
      )
      
    }
  )
  # Isolated observeEvent() which updates all the UI controls independently of the plot rendering observeEvent()
  observeEvent(
    {
      #input$display_position_range
      input$switch_target
      input$force_ui
    },
    {
      target_gene = input$switch_target
      merged_df3 = cbind(get(paste0(input$switch_target, '_merged_df3')))
      
      position_max=max(merged_df3[['position']])
      position_min=min(merged_df3[['position']])
      min_ligand_distance=min(merged_df3$ligand_distance)
      max_ligand_distance=max(merged_df3$ligand_distance)
      mutable_df3 = cbind(merged_df3)

      updateCheckboxGroupInput(
        session,
        "corr_selected",
        choiceNames = colnames(get(paste0(input$switch_target,"_corr_df_m3_f"))),
        choiceValues = colnames(get(paste0(input$switch_target,"_corr_df_m3_f"))),
        selected = c("FoldX", "DeepDDG", "mCSM.DUET")
      )
      
      updateSliderInput(
        session, 
        "display_position_range",
        min = position_min,
        max = position_max
      )
      
      updateNumericInput(session, "selected_logop_snp_position", min = position_min, max = position_max, value = position_min)
      updateNumericInput(session, "selected_logop_ed_position", min = position_min, max = position_max, value = position_min)
      updateNumericInput(session, "corr_lig_dist", min = min_ligand_distance, max = max_ligand_distance, value = min_ligand_distance)
      
      updateNumericInput(session, "snp_ligand_dist", min = min(merged_df3$ligand_distance), max = max(merged_df3$ligand_distance))
      updateNumericInput(session, "snp_interface_dist", min = min(merged_df3$interface_dist), max = max(merged_df3$interface_dist))
      updateNumericInput(session, "snp_nca_dist", min = min(merged_df3$nca_distance), max = max(merged_df3$nca_distance))
      
    }
  )
  observeEvent(
    {
      input$display_position_range
      input$stability_snp_param
      input$logoplot_colour_scheme
      input$omit_snp_count
      input$switch_target
      input$force
    },
    {
      print("entering main observeEvent()")
      # C O M P A T I B I L I T Y
      #gene=input$switch_target
      #drug=target_map[[gene]]
      target_gene = input$switch_target
      merged_df3 = cbind(get(paste0(input$switch_target, '_merged_df3')))
      
      # position_max=max(merged_df3[['position']])
      # position_min=min(merged_df3[['position']])
      # min_ligand_distance=min(merged_df3$ligand_distance)
      # max_ligand_distance=max(merged_df3$ligand_distance)
      # FIXME: these are IMPORTANT
      # # add "pos_count" position count column
      # merged_df3=merged_df3 %>% dplyr::add_count(position)
      # merged_df3$pos_count=merged_df3$n
      # merged_df3$n=NULL
      # 
      mutable_df3 = cbind(merged_df3)
      # 
      # # re-sort the dataframe according to position count
      sorted_df = cbind(merged_df3)
      sorted_df = sorted_df %>% arrange(pos_count)
      
      # 
      outdir = paste0(load_dir, "Data/", drug, '/output/')
      indir  = paste0(load_dir, "Data/", drug , "/input/")
      
      
      #### nasty special-purpose merged_df3 variants ####
      # FIXME: SLOW
      # corr_plotdf = corr_data_extract(
      #   merged_df3
      #   , gene = gene
      #   , drug = drug
      #   , extract_scaled_cols = F
      # )
      
      #input$stability_snp_param
      
      # updateCheckboxGroupInput(
      #   session,
      #   "corr_selected",
      #   choiceNames = colnames(get(paste0(input$switch_target,"_corr_df_m3_f"))),
      #   choiceValues = colnames(get(paste0(input$switch_target,"_corr_df_m3_f"))),
      #   selected = c("FoldX", "DeepDDG", "mCSM.DUET")
      # )
      # 
      # updateSliderInput(
      #   session, 
      #   "display_position_range",
      #   min = position_min,
      #   max = position_max
      #   #, value = c(position_min, position_min+150)
      # )
      # 
      # updateNumericInput(session, "selected_logop_snp_position", min = position_min, max = position_max, value = position_min)
      # updateNumericInput(session, "selected_logop_ed_position", min = position_min, max = position_max, value = position_min)
      # updateNumericInput(session, "corr_lig_dist", min = min_ligand_distance, max = max_ligand_distance, value = min_ligand_distance)
      # 
      # updateNumericInput(session, "snp_ligand_dist", min = min(merged_df3$ligand_distance), max = max(merged_df3$ligand_distance))
      # updateNumericInput(session, "snp_interface_dist", min = min(merged_df3$interface_dist), max = max(merged_df3$interface_dist))
      # updateNumericInput(session, "snp_nca_dist", min = min(merged_df3$nca_distance), max = max(merged_df3$nca_distance))
      
      
      
      stability_colname      = stability_boxes_df[stability_boxes_df$stability_type==input$stability_snp_param,"stability_colname"]
      outcome_colname        = stability_boxes_df[stability_boxes_df$stability_type==input$stability_snp_param,"outcome_colname"]
      
      display_position_range = input$display_position_range
      plot_min=display_position_range[1]
      plot_max=display_position_range[2]
      
      logoplot_colour_scheme = input$logoplot_colour_scheme
      omit_snp_count = input$omit_snp_count
      
      #print(paste0('Plotting positions between: ', plot_min, ' and ', plot_max))
      
      subset_mutable_df3=mutable_df3[(mutable_df3$position>=plot_min & mutable_df3$position <=plot_max),]
      
      subset_mutable_df3=mutable_df3[(mutable_df3$position>=plot_min & mutable_df3$position <=plot_max),]
      subset_sorted_df=sorted_df[(sorted_df$position>=plot_min & sorted_df$position <=plot_max),]
      
      #### LogoPlotSnps ####
      output$LogoPlotSnps = renderPlot(
        LogoPlotSnps(subset_mutable_df3,
                     aa_pos_drug = get(paste0(target_gene,"_aa_pos_drug")),
                     active_aa_pos = get(paste0(target_gene,"_active_aa_pos")),
                     aa_pos_lig1 = get(paste0(target_gene,"_aa_pos_lig1")),
                     aa_pos_lig2 = get(paste0(target_gene,"_aa_pos_lig2")),
                     aa_pos_lig3 = get(paste0(target_gene,"_aa_pos_lig3")),
                     my_logo_col = logoplot_colour_scheme,
                     omit_snp_count = omit_snp_count
                     
        )
      )
      
      ### NGLViewer ####
      # Structure Viewer WebGL/NGLViewR window
      output$structure <- renderNGLVieweR({
        #ngl_gene=isolate(input$switch_target)
        ngl_gene=input$switch_target
        ngl_drug=target_map[[ngl_gene]]
        ngl_pdb_file=paste0(load_dir, "Data/", ngl_drug, '/output/depth/', ngl_gene, '_complex.pdb')
        print(ngl_pdb_file)
        NGLVieweR(ngl_pdb_file) %>%
          addRepresentation("cartoon",
                            param = list(name = "cartoon",
                                         color="tan"
                                         #, colorScheme = "chainid"
                            )
          ) %>%
          stageParameters(backgroundColor = "lightgrey") %>%
          setQuality("high") %>%
          setFocus(0) %>%
          setSpin(FALSE)
      })
      
      
      #### Shared dataTable() ####
      output$table = DT::renderDataTable(
        datatable(subset_sorted_df[,table_columns],
                  filter="top",
                  selection = "single"
        )
      )
      
    }
  )

  observeEvent(
    {
      input$force
      input$switch_target
    },
    {
      target_gene = input$switch_target
      
      #### DM OM Plots ####
      #dm_om_param
      # order needs to be:
      # embb_lf_duet, embb_lf_foldx, embb_lf_deepddg, embb_lf_dynamut2, embb_lf_dist_gen, 
      # embb_lf_consurf, embb_lf_provean, embb_lf_snap2, embb_lf_mcsm_lig, embb_lf_mmcsm_lig,
      # embb_lf_mcsm_ppi2, SOMETHING NA
      
      # embb_lf_mmcsm_lig SOMETHING NA, 
      #dm_om_selection=input$dm_om_param
      #dm_om_df = dm_om_map[[dm_om_selection]]
      #output$lf_bp2 = renderPlot(lf_bp2(get(paste0(input$switch_target, '_', dm_om_df))))
      
      output$lf_bp2 = renderPlot(
        cowplot::plot_grid(
          plotlist = lapply(
            ls(name=.GlobalEnv,
               pattern=paste0(
                 target_gene,
                 '_lf_'
               )
            ),
            function(x){
              lf_bp2(get(x))
            }
          )#, nrow=3
        ), height=800
      )
    }
    )
  
  # FIXME: Doesn't add selected table rows correctly
  observeEvent(
    {
      input$table_rows_selected
    },
    {
      # having to duplicate this is a bit annoying :-(
      ngl_merged_df3=cbind(get(paste0(input$switch_target, '_merged_df3')))
      ngl_sorted_df = cbind(ngl_merged_df3)
      ngl_sorted_df = ngl_sorted_df %>% arrange(pos_count)
      
      position_max=max(ngl_merged_df3[['position']])
      position_min=min(ngl_merged_df3[['position']])
      display_position_range = input$display_position_range
      plot_min=display_position_range[1]
      plot_max=display_position_range[2]
      #ngl_subset_df=ngl_merged_df3[(ngl_merged_df3$position>=plot_min & ngl_merged_df3$position <=plot_max),]
      ngl_subset_df=ngl_sorted_df[(ngl_sorted_df$position>=plot_min & ngl_sorted_df$position <=plot_max),]
      
      
      #table_rows_selected = isolate(input$table_rows_selected)
      table_rows_selected = input$table_rows_selected
      class(table_rows_selected)
      #cat(paste0("Target: ", as.character(input$switch_target), "\nTable Rows for NGLViewR: ", as.character(table_rows_selected)))
      
      struct_pos=(as.character(ngl_subset_df[table_rows_selected,"position"]))
      cat(paste0('Table Index: ', table_rows_selected, "position: ", struct_pos))
      
      NGLVieweR_proxy("structure") %>%
        #addSelection('ball+stick'
        addSelection('hyperball'
                     , param = list(
                       name = "Pos"
                       , sele = struct_pos
                       #, color = "#00ff00"
                       , colorValue="00ff00"
                       , colorScheme="element"
                     )
        )
      #cat(paste0('Done NGLViewR addSelection for: ', positions_to_add))
    }
  )
  #### Correlation observeEvent ####
  # Yet another special-case observeEvent to handle the correlation pair plot
  
  observeEvent(
    {
      input$corr_selected
      input$corr_method
      input$corr_lig_dist
    },
    {
      dist_cutoff_user = input$corr_lig_dist
      target_gene=input$switch_target
      plot_title=paste0(target_map[[target_gene]],"/",target_gene)
      
      corr_plot_df = get(
        paste0(
          input$switch_target,"_corr_df_m3_f"
        )
      )[,c(input$corr_selected, "dst_mode")]
      
      #if ( dist_cutoff_user >= 2) {
      #corr_plotdf_subset = corr_plot_df[corr_plot_df[['Lig.Dist']] < dist_cutoff_user,]
      #}
      # else {
      #   corr_plotdf_subset = corr_plot_df
      # }
      
      #### Correlation using ggpairs() ####
      output$my_corr_pairs = renderPlot(
        dashboard_ggpairs(
          corr_plot_df,
          plot_title = plot_title,
          method = input$corr_method,
          tt_args_size = 7,
          gp_args_size = 7
        ), height = 900
      )
    }
  )
}