#' Function for launching the user friendly GUI client for \code{cytofkit-package}
#' 
#' This GUI provides an easy way to apply \code{cytofkit} package. 
#' Main parameters for running 'cytofkit' main function were integrated in this GUI, 
#' and each parameter has a help button to show the instructions. 
#' The \code{cytofkit} analysis will be automatically started after submitting.
#' 
#' @author Hao Chen
#' @return the GUI for \code{cytofkit-package}
#' @import tcltk
#' @export
#' @seealso \code{\link{cytofkit-package}}, \code{\link{cytofkit}}
#' @references \url{http://signbioinfo.github.io/cytofkit/}
#' @examples
#' #cytofkit_GUI()  # remove the hash symbol to run
cytofkit_GUI <- function() {
  
  ##--------------------------##
  ## parameter initialization ##
  ##--------------------------##
  
  fcsFiles <- ""
  cur_dir <- getwd()
  mergeMethods <- c("all", "min", "ceil", "fixed")
  transformMethods <- c("autoLgcl", "cytofAsinh", "logicle", "none")
  redMethods <- c("pca", "isomap", "tsne")
  vizMethods <- c("pca", "isomap", "tsne", "NULL")
  clusterMethods <- c("Rphenograph", "ClusterX", "DensVM", "FlowSOM", "NULL")
  progressionMethods <- c("diffusionmap", "isomap", "NULL")
  fixedLgclParas = c(l_w = 0.5, l_t = 500000, l_m = 4.5, l_a = 0)
  
  rawFCSdir <- tclVar(cur_dir)
  fcsFile <- tclVar("")
  resDir <- tclVar(cur_dir)
  projectName <- tclVar("cytofkit")
  mergeMethod <- tclVar("ceil")
  fixedNum <- tclVar("5000")
  markers <- tclVar("")
  transformMethod <- tclVar("autoLgcl")
  progressionMethod <- tclVar("NULL")
  Rphenograph_k <- tclVar("30")
  tsne_perp <- tclVar("30")
  tsne_maxIter <- tclVar("1000")
  FlowSOM_k <- tclVar("40")
  seed <- tclVar("42")
  
  # logicle parameters
  l_w <- tclVar(fixedLgclParas[1])
  l_t <- tclVar(fixedLgclParas[2])
  l_m <- tclVar(fixedLgclParas[3])
  l_a <- tclVar(fixedLgclParas[4])
  
  clusterSelect <- c()
  i <- 1
  while (i <= length(clusterMethods)) {
    aux <- paste("clusterSelect", i, sep = "")
    clusterSelect <- c(clusterSelect, as.character(aux))
    tclvalue(clusterSelect[i]) <- "0"
    i <- i + 1
  }
  tclvalue(clusterSelect[1]) <- "1"  # default Rphenograph
  
  redSelect <- c()
  i <- 1
  while (i <= length(redMethods)) {
    aux <- paste("redSelect", i, sep = "")
    redSelect <- c(redSelect, as.character(aux))
    tclvalue(redSelect[i]) <- "0"
    i <- i + 1
  }
  tclvalue(redSelect[3]) <- "1"  # default tsne 
  
  vizSelect <- c()
  i <- 1
  while (i <= length(vizMethods)) {
    aux <- paste("vizSelect", i, sep = "")
    vizSelect <- c(vizSelect, as.character(aux))
    tclvalue(vizSelect[i]) <- "0"
    i <- i + 1
  }
  tclvalue(vizSelect[3]) <- "1"  # default tsne 
  
  ret_var <- tclVar("")
  
  ##-------------------##
  ##  button functions ##
  ##-------------------##
  
  highCell_warning <- function() {
    #potentially_slow_methods <- c("all", "DensVM", "isomap")
    #if(any(potentially_slow_methods) %in% para){}
    tkmessageBox(title = "Warning",
                 message = "Please note that using the options DensVM or isomap with more than 10,000 cells will be very slow!")
  }
  
  reset_rawFCS_dir <- function() {
    rawFCS_dir <- ""
    rawFCS_dir <- tclvalue(tkchooseDirectory(title = "Choose your rawFCS direcetory ..."))
    if (rawFCS_dir != "") {
      tclvalue(rawFCSdir) <- rawFCS_dir
      tclvalue(resDir) <- rawFCS_dir
    }
  }
  
  reset_res_dir <- function() {
    res_dir <- ""
    res_dir <- tclvalue(tkchooseDirectory(title = "Choose your result directory ..."))
    if (res_dir != "") {
      tclvalue(resDir) <- res_dir
    }
  }
  
  reset_fcs_data <- function() {
    fnames <- ""
    fnames <- tk_choose.files(default = paste(tclvalue(rawFCSdir), 
                                              "fcs", sep = .Platform$file.sep), caption = "Select FCS files", 
                              multi = TRUE, filters = matrix(c("{fcs files}", "{.fcs}"), 
                                                             1, 2), index = 1)
    if (length(fnames) >= 1) {
      fnames <- fnames[!(grepl(paste0(.Platform$file.sep, 
                                      "fcs$"), fnames))]  # remove empty .fcs files
      tclvalue(fcsFile) <- paste(fnames, collapse = "}{")
    }
  }
  
  reset_para_data <- function() {
    
    if (tclvalue(fcsFile) == "" && tclvalue(rawFCSdir) == "") {
      tkmessageBox(title = "cytofkit: an Integrated Mass Cytometry Data Analysis Pipeline", 
                   message = "Please input your \"rawFCSdirectory\" or \"fcsFile\".", 
                   icon = "info", type = "ok")
    }
    if (tclvalue(fcsFile) != "") {
      fcsFiles <- strsplit(tclvalue(fcsFile), "}{", fixed = TRUE)[[1]]
    }
    fcsDir <- tclvalue(rawFCSdir)
    selectMarkers <- getParameters_GUI(fcsFiles, fcsDir)
    
    if (length(selectMarkers) > 0) {
      tclvalue(markers) <- paste(selectMarkers, collapse = "}{")
    }
  }
  
  reset_num2null <- function() {
    tclvalue(fixedNum) <- "NULL"
  }
  
  method_all_warning <- function(){
    reset_num2null()
    highCell_warning()
  }
  
  reset_num2any <- function() {
    tclvalue(fixedNum) <- "5000"
  }
  
  rawFCSdir_help <- function() {
    tkmessageBox(title = "rawFCSdir", message = "The directory that contains fcs files.", 
                 icon = "info", type = "ok")
  }
  
  fcsFile_help <- function() {
    tkmessageBox(title = "fcsFiles", message = "The fcs files to be analyzed. One or multiple fcs files are allowed. When multiple fcs files are selected, cells from each fcs file are combined for analysis.", 
                 icon = "info", type = "ok")
  }
  
  para_help <- function() {
    tkmessageBox(title = "markers", message = "Select the list of makers to be used for analysis.", 
                 icon = "info", type = "ok")
  }
  
  projectName_help <- function() {
    tkmessageBox(title = "projectName", message = "A prefix that will be added to the names of result files.", 
                 icon = "info", type = "ok")
  }
  
  mergeMethod_help <- function() {
    tkmessageBox(title = "mergeMethod", message = "When multiple fcs files are selected, cell expression data can be merged using one of the four different methods including \"ceil\",\"all\", \"min\",\"fixed\". \n\n\"ceil\" (the default option): up to a fixed number (specified by fixedNum) of cells are sampled without replacement from each fcs file and combined for analysis. \n\n\"all\": all cells from each fcs file are combined for analysis. \n\n\"min\": The minimum number of cells among all the selected fcs files are sampled from each fcs file and combined for analysis. \n\n\"fixed\": a fixed num (specified by fixedNum) of cells are sampled (with replacement when the total number of cell is less than fixedNum) from each fcs file and combined for analysis.", 
                 icon = "info", type = "ok")
  }
  
  fixedNum_help <- function() {
    tkmessageBox(title = "fixedNum", message = "Up to fixedNum of cells from each fcs file are used for analysis.", 
                 icon = "info", type = "ok")
  }
  
  rPk_help <- function() {
    tkmessageBox(title = "Rphenograph K", message = "Number of nearest neighbours to pass to Rphenograph.", 
                 icon = "info", type = "ok")
  }
  
  fSk_help <- function() {
    tkmessageBox(title = "FlowSOM K", message = "Number of clusters for meta clustering in FlowSOM.", 
                 icon = "info", type = "ok")
  }
  
  transformMethod_help <- function() {
    tkmessageBox(title = "transformationMethod", message = "Data Transformation method, including \"cytofAsinh\"(Customized Asinh transformation for CyTOF data), \"autoLgcl\"(automatic logicle transformation for CyTOF data), \"logicle\"(customize your own parameters for logicle transformation) and \"none\"(if your data is already transformed).", 
                 icon = "info", type = "ok")
  }
  
  reductionMethods_help <- function() {
    tkmessageBox(title = "reductionMethods", message = "The method(s) used for reducing the dimensions, multiple selections are allowed (!!TO BE CHECKED!!). Including \"pca\", \"isomap\", \"tsne\". \n\nWARNING: \"tsne\" is the default selection, \"isomap\" may take long time.", 
                 icon = "info", type = "ok")
  }
  
  cluster_help <- function() {
    tkmessageBox(title = "clusterMethods", message = "The method(s) for clustering, including \"DensVM\", \"ClusterX\", \"Rphenograph\", and \"FlowSOM\". \n\nIf \"NULL\" was selected, no clustering will be performed.", 
                 icon = "info", type = "ok")
  }
  
  visualizationMethods_help <- function() {
    tkmessageBox(title = "visualizationMethods", message = "The method(s) used for visualizing the clustering results, multiple selections are allowed. Including \"pca\", \"isomap\", \"tsne\". \n\nWARNING: \"tsne\" is the default selection, \"isomap\" may take long time.", 
                 icon = "info", type = "ok")
  }
  
  progressionMethod_help <- function() {
    tkmessageBox(title = "progressionMethod", message = "The method used for cellular progression analysis including \"diffusion map\" and \"isomap\"\n\nIf \"NULL\" was selected, no progression estimation will be performed.", 
                 icon = "info", type = "ok")
  }
  
  resDir_help <- function() {
    tkmessageBox(title = "resDir", message = "The directory where result files will be generated", 
                 icon = "info", type = "ok")
  }
  
  reset <- function() {
    tclvalue(rawFCSdir) = cur_dir
    tclvalue(fcsFile) = ""
    tclvalue(resDir) = cur_dir
    tclvalue(projectName) = "cytofkit"
    tclvalue(mergeMethod) = mergeMethods[3]
    tclvalue(fixedNum) = "5000"
    tclvalue(markers) = ""
    tclvalue(transformMethod) = "autoLgcl"
    tclvalue(redSelect[1]) <- "0"
    tclvalue(redSelect[2]) <- "0"
    tclvalue(redSelect[3]) <- "1"
    tclvalue(clusterSelect[1]) = "0"
    tclvalue(clusterSelect[2]) = "1"
    tclvalue(clusterSelect[3]) = "0"
    tclvalue(clusterSelect[4]) = "0"
    tclvalue(vizSelect[1]) <- "0"
    tclvalue(vizSelect[2]) <- "0"
    tclvalue(vizSelect[3]) <- "1"
    tclvalue(progressionMethod) <- "NULL"
    tclvalue(Rphenograph_k) <- "30"
    tclvalue(FlowSOM_k) <- "40"
    tclvalue(tsne_perp) <- "30"
    tclvalue(tsne_maxIter) <- "1000"
    tclvalue(seed) <- "42"
  }
  
  submit <- function() {
    has_error = FALSE
    if (tclvalue(markers) == "") {
      tkmessageBox(title = "cytofkit: an Integrated Analysis Pipeline for Mass Cytometry Data", 
                   message = "Please select the markers for your analysis.", 
                   icon = "info", type = "ok")
      has_error = TRUE
    }
    
    if (has_error == FALSE) {
      tclvalue(ret_var) <- "OK"
      tkdestroy(tt)
    }
  }
  
  quit <- function() {
    tkdestroy(tt)
  }
  
  
  ##----------------##
  ##  build the GUI ##
  ##--------------- ##
  
  ## head line
  tt <- tktoplevel(borderwidth = 20)
  tkwm.title(tt, "cytofkit: an Integrated Analysis Pipeline for Mass Cytometry Data")
  
  if(.Platform$OS.type == "windows"){
    box_length <- 63
  }else{
    box_length <- 55 
  }
  cell_width <- 3
  bt_width <- 8
  #hb_width <- 8
  
  imgfile <- system.file("extdata", "help.png", package = "cytofkit")
  image1 <- tclVar()
  tkimage.create("photo", image1, file = imgfile)
  image2 <- tclVar()
  tkimage.create("photo", image2)
  tcl(image2, "copy", image1, subsample = 6)
  
  ## rawFCSdir
  rawFCSdir_label <- tklabel(tt, text = "Raw FCS Directory :")
  rawFCSdir_entry <- tkentry(tt, textvariable = rawFCSdir, width = box_length)
  rawFCSdir_button <- tkbutton(tt, text = " Choose... ", width = bt_width, command = reset_rawFCS_dir)
  rawFCSdir_hBut <- tkbutton(tt, image = image2, command = rawFCSdir_help)
  
  ## resDir
  resDir_label <- tklabel(tt, text = "Result Directory :")
  resDir_entry <- tkentry(tt, textvariable = resDir, width = box_length)
  resDir_button <- tkbutton(tt, text = " Choose... ", width = bt_width, 
                            command = reset_res_dir)
  resDir_hBut <- tkbutton(tt, image = image2, command = resDir_help)
  
  ## fcsFiles
  fcsFile_label <- tklabel(tt, text = "FCS File(s) :")
  fcsFile_entry <- tkentry(tt, textvariable = fcsFile, width = box_length)
  fcsFile_button <- tkbutton(tt, text = " Select... ", width = bt_width, 
                             command = reset_fcs_data)
  fcsFile_hBut <- tkbutton(tt, image = image2, command = fcsFile_help)
  
  ## markers
  markers_label <- tklabel(tt, text = "Markers :")
  markers_entry <- tkentry(tt, textvariable = markers, width = box_length)
  markers_button <- tkbutton(tt, text = " Select... ", width = bt_width, 
                             command = reset_para_data)
  markers_hBut <- tkbutton(tt, image = image2, command = para_help)
  
  ## projectName
  projectName_label <- tklabel(tt, text = "Project Name :")
  projectName_entry <- tkentry(tt, textvariable = projectName, width = box_length)
  projectName_hBut <- tkbutton(tt, image = image2, command = projectName_help)
  
  ## mergeMethod && fixedNum
  mergeMethod_label <- tklabel(tt, text = "Merge Method :")
  mergeMethod_hBut <- tkbutton(tt, image = image2, command = mergeMethod_help)
  merge_method_rbuts <- tkframe(tt)
  tkpack(tklabel(merge_method_rbuts, text = ""), side = "left")
  tkpack(tkradiobutton(merge_method_rbuts, text = mergeMethods[1], 
                       variable = mergeMethod, value = mergeMethods[1], command = method_all_warning), 
         side = "left")
  tkpack(tkradiobutton(merge_method_rbuts, text = mergeMethods[2], 
                       variable = mergeMethod, value = mergeMethods[2], command = reset_num2null), 
         side = "left")
  tkpack(tkradiobutton(merge_method_rbuts, text = mergeMethods[3], 
                       variable = mergeMethod, value = mergeMethods[3], command = reset_num2any), 
         side = "left")
  tkpack(tkradiobutton(merge_method_rbuts, text = mergeMethods[4], 
                       variable = mergeMethod, value = mergeMethods[4], command = reset_num2any), 
         side = "left")
  tkpack(tkentry(merge_method_rbuts, textvariable = fixedNum, 
                 width = 9), side = "right")
  tkpack(tklabel(merge_method_rbuts, text = "Fixed Number :"), 
         side = "right")
  tkpack(tklabel(merge_method_rbuts, text = "                 "), 
         side = "left")
  fixedNum_hBut <- tkbutton(tt, image = image2, command = fixedNum_help)
  
  ## transformMethod
  transformMethod_label <- tklabel(tt, text = "Transformation Method :")
  transformMethod_hBut <- tkbutton(tt, image = image2,
                                   command = transformMethod_help)
  transformMethod_rbuts <- tkframe(tt)
  tkpack(tklabel(transformMethod_rbuts, text = ""), side = "left")
  tkpack(tkradiobutton(transformMethod_rbuts, text = transformMethods[1], 
                       variable = transformMethod, value = transformMethods[1]), side = "left")
  tkpack(tkradiobutton(transformMethod_rbuts, text = transformMethods[2],
                       variable = transformMethod, value = transformMethods[2]), side = "left")
  tkpack(tkradiobutton(transformMethod_rbuts, text = "Fixedlogicle",
                       command = function(){ 
                         fixedLgclParas <- fixedLogicleParameters_GUI(fixedLgclParas) 
                         tclvalue(l_w) <- fixedLgclParas[1] 
                         tclvalue(l_t) <- fixedLgclParas[2] 
                         tclvalue(l_m) <- fixedLgclParas[3] 
                         tclvalue(l_a) <- fixedLgclParas[4] 
                       },
                       variable = transformMethod, value = transformMethods[3]), side = "left")
  tkpack(tkradiobutton(transformMethod_rbuts, text = transformMethods[4],
                       variable = transformMethod, value = transformMethods[4]), side = "left")
  
  ## reductionMethods
  reductionMethods_label <- tklabel(tt, text = "Dim. red. Method(s) :")
  reductionMethods_hBut <- tkbutton(tt, image = image2,
                                        command = reductionMethods_help)
  reductionMethods_cbuts <- tkframe(tt)
  tkpack(tklabel(reductionMethods_cbuts, text = ""), side = "left")
  tkpack(tkcheckbutton(reductionMethods_cbuts, text = redMethods[1],
                       variable = eval(redSelect[1])), side = "left")
  tkpack(tkcheckbutton(reductionMethods_cbuts, text = redMethods[2],
                       variable = eval(redSelect[2])), side = "left")
  tkpack(tkcheckbutton(reductionMethods_cbuts, text = redMethods[3],
                       variable = eval(redSelect[3])), side = "left")
  #tkpack(tkcheckbutton(reductionMethods_cbuts, text = redMethods[4],
  #                     variable = eval(redSelect[4])), side = "left")
  #tkpack(tklabel(reductionMethods_cbuts, text = "                 "), side = "left")
  #tkpack(tklabel(reductionMethods_cbuts, text = "Seed"), side = "left")
  #tkpack(tkentry(reductionMethods_cbuts, textvariable = seed, width = 4), side = "left")
  
  ## cluster method
  cluster_label <- tklabel(tt, text = "Cluster Method(s) :")
  cluster_hBut <- tkbutton(tt, image = image2, command = cluster_help)
  
  clusterMethods_cbuts <- tkframe(tt)
  tkpack(tklabel(clusterMethods_cbuts, text = ""), side = "left")
  tkpack(tkcheckbutton(clusterMethods_cbuts, text = clusterMethods[1], 
                       variable = eval(clusterSelect[1])), side = "left")
  tkpack(tkcheckbutton(clusterMethods_cbuts, text = clusterMethods[2], 
                       variable = eval(clusterSelect[2])), side = "left")
  tkpack(tkcheckbutton(clusterMethods_cbuts, text = clusterMethods[3], 
                       variable = eval(clusterSelect[3]), command = highCell_warning), side = "left")
  tkpack(tkcheckbutton(clusterMethods_cbuts, text = clusterMethods[4], 
                       variable = eval(clusterSelect[4])), side = "left")
  tkpack(tkcheckbutton(clusterMethods_cbuts, text = clusterMethods[5], 
                       variable = eval(clusterSelect[5])), side = "left")
  
  ## cluster param (Rphenograph_k and FlowSOM_k)
  rphenoK_label <- tklabel(tt, text = "Rphenograph_k:")
  rphenoK_hBut <- tkbutton(tt, image = image2, command = rPk_help)
  cluster_Param <- tkframe(tt)
  tkpack(tklabel(cluster_Param, text = " "), side = "left")
  tkpack(tkentry(cluster_Param, textvariable = Rphenograph_k, width = 4), side = "left")
  tkpack(tklabel(cluster_Param, text = "                 "), side = "left")
  tkpack(tklabel(cluster_Param, text = "tsne Perplexity"), side = "left")
  tkpack(tkentry(cluster_Param, textvariable = tsne_perp, width = 4), side = "left")
  tkpack(tklabel(cluster_Param, text = "tsne Max Iterations"), side = "left")
  tkpack(tkentry(cluster_Param, textvariable = tsne_maxIter, width = 4), side = "left")
  tkpack(tkbutton(cluster_Param, image = image2, command = fSk_help), side = "right")
  tkpack(tkentry(cluster_Param, textvariable = FlowSOM_k, width = 4), side = "right")
  tkpack(tklabel(cluster_Param, text = "FlowSOM_k:"), side = "right")
  
  ## visualizationMethods
  visualizationMethods_label <- tklabel(tt, text = "Visualization Method(s) :")
  visualizationMethods_hBut <- tkbutton(tt, image = image2,
                                        command = visualizationMethods_help)
  visualizationMethods_cbuts <- tkframe(tt)
  tkpack(tklabel(visualizationMethods_cbuts, text = ""), side = "left")
  tkpack(tkcheckbutton(visualizationMethods_cbuts, text = vizMethods[1],
                       variable = eval(vizSelect[1])), side = "left")
  tkpack(tkcheckbutton(visualizationMethods_cbuts, text = vizMethods[2],
                       variable = eval(vizSelect[2]), command = highCell_warning), side = "left")
  tkpack(tkcheckbutton(visualizationMethods_cbuts, text = vizMethods[3],
                       variable = eval(vizSelect[3])), side = "left")
  tkpack(tkcheckbutton(visualizationMethods_cbuts, text = vizMethods[4],
                       variable = eval(vizSelect[4])), side = "left")
  tkpack(tklabel(visualizationMethods_cbuts, text = "                 "), side = "left")
  tkpack(tklabel(visualizationMethods_cbuts, text = "Seed"), side = "left")
  tkpack(tkentry(visualizationMethods_cbuts, textvariable = seed, width = 4), side = "left")
  
  ## progressionMethod
  progressionMethod_label <- tklabel(tt, text = "Cellular Progression :")
  progressionMethod_hBut <- tkbutton(tt, image = image2, 
                                     command = progressionMethod_help)
  progressionMethod_rbuts <- tkframe(tt)
  tkpack(tklabel(progressionMethod_rbuts, text = ""), side = "left")
  tkpack(tkradiobutton(progressionMethod_rbuts, text = progressionMethods[1], 
                       variable = progressionMethod, value = progressionMethods[1]), side = "left")
  tkpack(tkradiobutton(progressionMethod_rbuts, text = progressionMethods[2], 
                       variable = progressionMethod, value = progressionMethods[2], command = highCell_warning),
         side = "left")
  tkpack(tkradiobutton(progressionMethod_rbuts, text = progressionMethods[3], 
                       variable = progressionMethod, value = progressionMethods[3]), side = "left")
  
  ## submit / reset / quit
  submit_button <- tkbutton(tt, text = "Submit", command = submit)
  reset_button <- tkbutton(tt, text = "Reset", command = reset)
  quit_button <- tkbutton(tt, text = "Quit", command = quit)
  
  ## display GUI
  tkgrid(rawFCSdir_label, rawFCSdir_hBut, rawFCSdir_entry, rawFCSdir_button, 
         padx = cell_width)
  tkgrid.configure(rawFCSdir_label, rawFCSdir_entry, rawFCSdir_button, 
                   sticky = "e")
  tkgrid.configure(rawFCSdir_hBut, sticky = "e")
  
  tkgrid(fcsFile_label, fcsFile_hBut, fcsFile_entry, fcsFile_button, 
         padx = cell_width)
  tkgrid.configure(fcsFile_label, fcsFile_entry, fcsFile_button, 
                   sticky = "e")
  tkgrid.configure(fcsFile_hBut, sticky = "e")
  
  tkgrid(markers_label, markers_hBut, markers_entry, markers_button, 
         padx = cell_width)
  tkgrid.configure(markers_label, markers_entry, markers_button, 
                   sticky = "e")
  tkgrid.configure(markers_hBut, sticky = "e")
  
  tkgrid(resDir_label, resDir_hBut, resDir_entry, resDir_button, 
         padx = cell_width)
  tkgrid.configure(resDir_label, resDir_entry, resDir_button, 
                   sticky = "e")
  tkgrid.configure(resDir_hBut, sticky = "e")
  
  tkgrid(projectName_label, projectName_hBut, projectName_entry, padx = cell_width)
  tkgrid.configure(projectName_label, projectName_entry, sticky = "e")
  tkgrid.configure(projectName_hBut, sticky = "e")
  
  tkgrid(mergeMethod_label, mergeMethod_hBut, merge_method_rbuts, 
         fixedNum_hBut, padx = cell_width)
  tkgrid.configure(mergeMethod_label, sticky = "e")
  tkgrid.configure(mergeMethod_hBut, sticky = "e")
  tkgrid.configure(merge_method_rbuts, sticky = "w")
  tkgrid.configure(fixedNum_hBut, sticky = "w")
  
  tkgrid(transformMethod_label, transformMethod_hBut, transformMethod_rbuts,
         padx = cell_width)
  tkgrid.configure(transformMethod_label, sticky = "e")
  tkgrid.configure(transformMethod_rbuts, sticky = "w")
  tkgrid.configure(transformMethod_hBut, sticky = "e")
  
  tkgrid(reductionMethods_label, reductionMethods_hBut, 
         reductionMethods_cbuts, padx = cell_width)
  tkgrid.configure(reductionMethods_label, sticky = "e")
  tkgrid.configure(reductionMethods_cbuts, sticky = "w")
  tkgrid.configure(reductionMethods_hBut, sticky = "e")
  
  tkgrid(cluster_label, cluster_hBut, clusterMethods_cbuts, padx = cell_width)
  tkgrid.configure(cluster_label, sticky = "e")
  tkgrid.configure(clusterMethods_cbuts, sticky = "w")
  tkgrid.configure(cluster_hBut, sticky = "e")
  
  tkgrid(rphenoK_label, rphenoK_hBut, cluster_Param, padx = cell_width)
  tkgrid.configure(rphenoK_label, rphenoK_hBut, sticky = "e")
  tkgrid.configure(cluster_Param, sticky = "w")
  
  tkgrid(visualizationMethods_label, visualizationMethods_hBut, 
         visualizationMethods_cbuts, padx = cell_width)
  tkgrid.configure(visualizationMethods_label, sticky = "e")
  tkgrid.configure(visualizationMethods_cbuts, sticky = "w")
  tkgrid.configure(visualizationMethods_hBut, sticky = "e")
  
  tkgrid(progressionMethod_label, progressionMethod_hBut, progressionMethod_rbuts, 
         padx = cell_width)
  tkgrid.configure(progressionMethod_label, sticky = "e")
  tkgrid.configure(progressionMethod_rbuts, sticky = "w")
  tkgrid.configure(progressionMethod_hBut, sticky = "e")
  
  tkgrid(tklabel(tt, text = "\n"), padx = cell_width)  # leave blank line
  
  tkgrid(reset_button, tklabel(tt, text = ""), submit_button, 
         quit_button, padx = cell_width)
  tkgrid.configure(reset_button, sticky = "e")
  tkgrid.configure(quit_button, sticky = "w")
  
  tkwait.window(tt)
  
  
  ##-------------------##
  ## Return parameters ##
  ##-------------------##
  
  if (tclvalue(ret_var) != "OK") {
    okMessage <- "Analysis is cancelled."
  }else{
    fcsFiles <- strsplit(tclvalue(fcsFile), "}{", fixed = TRUE)[[1]]
    parameters <- strsplit(tclvalue(markers), "}{", fixed = TRUE)[[1]]
    
    redCheck <- c()
    i <- 1
    while (i <= length(redMethods)) {
      v <- as.numeric(tclvalue(redSelect[i])) > 0
      redCheck <- c(redCheck, v)
      i <- i + 1
    }
    
    clusterCheck <- c()
    i <- 1
    while (i <= length(clusterMethods)) {
      v <- as.numeric(tclvalue(clusterSelect[i])) > 0
      clusterCheck <- c(clusterCheck, v)
      i <- i + 1
    }
    
    vizCheck <- c()
    i <- 1
    while (i <= length(vizMethods)) {
      v <- as.numeric(tclvalue(vizSelect[i])) > 0
      vizCheck <- c(vizCheck, v)
      i <- i + 1
    }
    
    inputs <- list()
    inputs[["fcsFiles"]] <- fcsFiles
    inputs[["markers"]] <- parameters
    inputs[["mergeMethod"]] <- tclvalue(mergeMethod)
    inputs[["fixedNum"]] <- suppressWarnings(as.numeric(tclvalue(fixedNum)))
    inputs[["transformMethod"]] <- tclvalue(transformMethod)
    inputs[["dimReductionMethod"]] <- "tsne"
    inputs[["dimReductionMethod"]] <- redMethods[redCheck]
    inputs[["clusterMethods"]] <- clusterMethods[clusterCheck]
    inputs[["visualizationMethods"]] <- vizMethods[vizCheck]
    inputs[["progressionMethod"]] <- tclvalue(progressionMethod)
    inputs[["Rphenograph_k"]] <- tclvalue(Rphenograph_k)
    inputs[["tsne_perp"]] <- tclvalue(tsne_perp)
    inputs[["tsne_maxIter"]] <- tclvalue(tsne_maxIter)
    inputs[["FlowSOM_k"]] <- tclvalue(FlowSOM_k)
    inputs[["seed"]] <- tclvalue(seed)
    inputs[["projectName"]] <- tclvalue(projectName)
    inputs[["resultDir"]] <- tclvalue(resDir)
    
    inputs[["l_w"]] <- tclvalue(l_w)
    inputs[["l_t"]] <- tclvalue(l_t)
    inputs[["l_m"]] <- tclvalue(l_m)
    inputs[["l_a"]] <- tclvalue(l_a)
    
    
    # pass the parameters and run the cytofkit function
    cytofkit(fcsFiles = inputs[["fcsFiles"]],
             markers = inputs[["markers"]],
             projectName = inputs[["projectName"]],
             mergeMethod = inputs[["mergeMethod"]],
             fixedNum = inputs[["fixedNum"]],
             transformMethod = inputs[["transformMethod"]],
             dimReductionMethod = inputs[["dimReductionMethod"]],
             clusterMethods = inputs[["clusterMethods"]],
             visualizationMethods = inputs[["visualizationMethods"]],
             progressionMethod = inputs[["progressionMethod"]],
             Rphenograph_k = as.numeric(inputs[["Rphenograph_k"]]),
             FlowSOM_k = as.numeric(inputs[["FlowSOM_k"]]),
             seed = as.numeric(inputs[["seed"]]),
             clusterSampleSize = 500,
             resultDir = inputs[["resultDir"]],
             saveResults = TRUE,
             saveObject = TRUE,
             l_w = as.numeric(inputs[["l_w"]]), 
             l_t = as.numeric(inputs[["l_t"]]), 
             l_m = as.numeric(inputs[["l_m"]]), 
             l_a = as.numeric(inputs[["l_a"]]))
    
    okMessage <- paste0("Analysis done, results are saved under ",
                        inputs[["resultDir"]])
    RData_path <- paste0(inputs[["resultDir"]], .Platform$file.sep, inputs[["projectName"]], ".RData")
  }
  
  launchShinyAPP_GUI(message = okMessage, dir = inputs[["resultDir"]], obj = RData_path)
}


#' GUI for launching shiny APP
#' 
#' A shiny APP for interactive exploration of analysis results
#' 
#' @param message Message when asking if user wants to open the shiny APP
#' @param dir Result directory.
#' @param obj The RData piped from cytofkit function to the Shiny App
#' 
#' @return Window asking user if they wish to open shinyApp directly
#' @export
#' @examples
#' # launchShinyAPP_GUI()
launchShinyAPP_GUI <- function(message="cytofkit", dir = getwd(), obj = NULL){
  
  if(message == "Analysis is cancelled."){
    message("Analysis is cancelled!")
  }else{
    ifAPP <- tclVar("n")
    ss <- tktoplevel(borderwidth = 10)
    tkwm.title(ss, "cytofkit: Analysis Done")
    
    onYes <- function() {
      tclvalue(ifAPP) <- "y"
      tkdestroy(ss)
    }
    
    onNo <- function() {
      tclvalue(ifAPP) <- "n"
      tkdestroy(ss)
    }
    yesBut <- tkbutton(ss, text = " Yes ", command = onYes)
    noBut <- tkbutton(ss, text = " No ", command = onNo)
    openDirBut <- tkbutton(ss, text = "Open", command = function(){opendir(dir)})
    okBut <- tkbutton(ss, text = "OK", command = function(){tkdestroy(ss)})
    tkgrid(tklabel(ss, text = message))
    
    tkgrid(openDirBut)
    tkgrid(tklabel(ss, text = "\n"))
    tkgrid(tklabel(ss, text = "Launch Shiny APP to check your results:"))
    tkgrid(noBut, tklabel(ss, text = "    "), yesBut)
    tkgrid.configure(noBut, sticky = "e")
    tkgrid.configure(yesBut, sticky = "e")
    tkwait.window(ss)
    
    if(tclvalue(ifAPP) == "y"){
      cytofkitShinyAPP(obj)
    }
  }
}


## function for opening the results directory
opendir <- function(dir = getwd()){
  if (.Platform['OS.type'] == "windows"){
    shell.exec(dir)
  } else {
    system(paste(Sys.getenv("R_BROWSER"), dir))
  }
}


#' GUI for marker selection 
#' 
#' Extract the markers from the fcsfiles
#' 
#' @param fcsFile The name of the FCS file
#' @param rawFCSdir The path of the FCS file
#' @return List of markers for ddimension reduction and clustering
#' @examples 
#' #getParameters_GUI()
getParameters_GUI <- function(fcsFile, rawFCSdir) {
  
  if (missing(fcsFile)) {
    fcsFile <- list.files(path = rawFCSdir, pattern = ".fcs$", full.names = TRUE)
  }
  
  fcs <- suppressWarnings(read.FCS(fcsFile[1]))
  pd <- fcs@parameters@data
  markers <- paste(pd$name, "<", pd$desc, ">", sep = "")
  channels <- paste(pd$name, "<", pd$desc, ">", sep = "")
  
  if (length(markers) == 0) {
    stop("No markers found in the FCS file!")
  }
  
  # GUI
  markerChoice <- tclVar("")
  mm <- tktoplevel()
  tkwm.title(mm, "cytofkit: Marker Selection")
  scr <- tkscrollbar(mm, repeatinterval = 5, command = function(...) tkyview(tl, 
                                                                             ...))
  tl <- tklistbox(mm, height = 30, width = 40, selectmode = "multiple", yscrollcommand = function(...) tkset(scr, 
                                                                                                             ...), background = "white")
  OnOK <- function() {
    tclvalue(markerChoice) <- paste(markers[as.numeric(tkcurselection(tl)) + 
                                              1], collapse = "}{")
    tkdestroy(mm)
  }
  OK.but <- tkbutton(mm, text = " OK ", command = OnOK)
  tkgrid(tklabel(mm, text = "Please select your markers:"))
  tkgrid(tl, scr)
  tkgrid.configure(scr, rowspan = 4, sticky = "nsw")
  for (i in (1:length(markers))) {
    tkinsert(tl, "end", markers[i])
  }
  tkgrid(OK.but)
  tkwait.window(mm)
  
  # return parameters
  paras <- strsplit(tclvalue(markerChoice), "}{", fixed = TRUE)[[1]]
  paras <- channels[match(paras, markers)]
  return(paras)
} 


#' GUI for gettting parameter for logicle transformation
#' 
#' Extract the parameter for fixed logicle transformation
#' 
#' @param fixedLgclParas parameters vector containing w, t, m, a
#' @return Parameters for fixed logicle transformation
#' @examples 
#' #fixedLogicleParameters_GUI
fixedLogicleParameters_GUI <- function(fixedLgclParas=c(0.5, 500000, 4.5, 0)) {
  
  # logicle parameters
  l_w <- tclVar(fixedLgclParas[1])
  l_t <- tclVar(fixedLgclParas[2])
  l_m <- tclVar(fixedLgclParas[3])
  l_a <- tclVar(fixedLgclParas[4])
  
  cell_width <- 3
  box_length <- 10
  
  # GUI
  mm <- tktoplevel(borderwidth = 20)
  tkwm.title(mm, "Parameters for fixed logicle transformation")
  
  w_label <- tklabel(mm, text = "w :")
  w_entry <- tkentry(mm, textvariable = l_w, width = box_length)
  
  t_label <- tklabel(mm, text = "t :")
  t_entry <- tkentry(mm, textvariable = l_t, width = box_length)
  
  m_label <- tklabel(mm, text = "m :")
  m_entry <- tkentry(mm, textvariable = l_m, width = box_length)
  
  a_label <- tklabel(mm, text = "a :")
  a_entry <- tkentry(mm, textvariable = l_a, width = box_length)
  
  OnOK <- function(){
    tkdestroy(mm)
  }
  
  OK.but <- tkbutton(mm, text = " OK ", command = OnOK)
  
  tkgrid(tklabel(mm, text = "Specify your parameters\nfor logical transformation:"), columnspan=2)
  
  tkgrid(tklabel(mm, text = "\n"), padx = cell_width)  # leave blank line
  
  tkgrid(w_label, w_entry, padx = cell_width)
  tkgrid.configure(w_label, sticky = "e")
  tkgrid.configure(w_entry, sticky = "w")
  
  tkgrid(t_label, t_entry, padx = cell_width)
  tkgrid.configure(t_label, sticky = "e")
  tkgrid.configure(t_entry, sticky = "w")
  
  tkgrid(m_label, m_entry, padx = cell_width)
  tkgrid.configure(m_label, sticky = "e")
  tkgrid.configure(m_entry, sticky = "w")
  
  tkgrid(a_label, a_entry, padx = cell_width)
  tkgrid.configure(a_label, sticky = "e")
  tkgrid.configure(a_entry, sticky = "w")
  
  tkgrid(tklabel(mm, text = "\n"), padx = cell_width)  # leave blank line
  
  tkgrid(tklabel(mm, text = ""), OK.but, padx = cell_width)
  tkgrid.configure(OK.but, sticky = "w")
  tkwait.window(mm)
  
  # return parameters
  paras <- c(tclvalue(l_w), tclvalue(l_t), tclvalue(l_m), tclvalue(l_a))
  paras <- as.numeric(paras)
  return(paras)
}