#' Data summary

#' @description

#' Module and its utils to display the number of rows and subjects in the filtered and unfiltered data.

#'

#' @details Handling different data classes:

#' `get_filter_overview()` is a pseudo S3 method which has variants for:

#' - `array` (`data.frame`, `DataFrame`, `array`, `Matrix` and `SummarizedExperiment`): Method variant

#' can be applied to any two-dimensional objects on which [ncol()] can be used.

#' - `MultiAssayExperiment`: for which summary contains counts for `colData` and all `experiments`.

#' - For other data types module displays data name with warning icon and no more details.

#'

#' Module includes also "Show/Hide unsupported" button to toggle rows of the summary table

#' containing datasets where number of observations are not calculated.

#'

#' @inheritParams module_teal_module

#'

#' @name module_data_summary

#' @rdname module_data_summary

#' @keywords internal

#' @return `NULL`.

NULL

#' @rdname module_data_summary

ui_data_summary <- function(id) {

      ),

        )

      )

    ),

      )

    )

  )

}

#' @rdname module_data_summary

srv_data_summary <- function(id, data) {

        }

      })

          # Ignore silent shiny error

          }

        } else {

                  )

                )

              }

            }

          )

          )

                    " (",

                    ),

                    ")"

                  )

                )

              )

            }

          )

        }

      })

    }

  )

}

#' @rdname module_data_summary

get_filter_overview_wrapper <- function(teal_data) {

  # Sort datanames in topological order

  )

      } else {

      }

      )

    }

  )

}

#' @rdname module_data_summary

#' @param current_data (`object`) current object (after filtering and transforming).

#' @param initial_data (`object`) initial object.

#' @param dataname (`character(1)`)

#' @param subject_keys (`character`) names of the columns which determine a single unique subjects

get_filter_overview <- function(current_data, initial_data, dataname, subject_keys) {

  } else {

  }

}

#' @rdname module_data_summary

get_filter_overview_array <- function(current_data,

                                      initial_data,

                                      dataname,

                                      subject_keys) {

      } else {

      }

    )

  } else {

      } else {

      },

      } else {

      }

    )

  }

}

#' @rdname module_data_summary

get_filter_overview_MultiAssayExperiment <- function(current_data, # nolint: object_length, object_name.

                                                     initial_data,

                                                     dataname) {

    } else {

    }

  )

        ),

      )

    }

  ))

  }

          )

        } else {

        }

      )

    }

  ))

}

#' App state management.

#'

#' @description

#' `r lifecycle::badge("experimental")`

#'

#' Capture and restore the global (app) input state.

#'

#' @details

#' This module introduces bookmarks into `teal` apps: the `shiny` bookmarking mechanism becomes enabled

#' and server-side bookmarks can be created.

#'

#' The bookmark manager presents a button with the bookmark icon and is placed in the tab-bar.

#' When clicked, the button creates a bookmark and opens a modal which displays the bookmark URL.

#'

#' `teal` does not guarantee that all modules (`teal_module` objects) are bookmarkable.

#' Those that are, have a `teal_bookmarkable` attribute set to `TRUE`. If any modules are not bookmarkable,

#' the bookmark manager modal displays a warning and the bookmark button displays a flag.

#' In order to communicate that a external module is bookmarkable, the module developer

#' should set the `teal_bookmarkable` attribute to `TRUE`.

#'

#' @section Server logic:

#' A bookmark is a URL that contains the app address with a `/?_state_id_=<bookmark_dir>` suffix.

#' `<bookmark_dir>` is a directory created on the server, where the state of the application is saved.

#' Accessing the bookmark URL opens a new session of the app that starts in the previously saved state.

#'

#' @section Note:

#' To enable bookmarking use either:

#' - `shiny` app by using `shinyApp(..., enableBookmarking = "server")` (not supported in `shinytest2`)

#' - set `options(shiny.bookmarkStore = "server")` before running the app

#'

#'

#' @inheritParams module_teal

#'

#' @return Invisible `NULL`.

#'

#' @aliases bookmark bookmark_manager bookmark_manager_module

#'

#' @name module_bookmark_manager

#' @rdname module_bookmark_manager

#'

#' @keywords internal

#'

NULL

#' @rdname module_bookmark_manager

ui_bookmark_panel <- function(id, modules) {

  # Render bookmark warnings count

          )

        }

      )

    )

  }

}

#' @rdname module_bookmark_manager

srv_bookmark_panel <- function(id, modules) {

    # Set up bookmarking callbacks ----

    # Register bookmark exclusions: do_bookmark button to avoid re-bookmarking

    # This bookmark can only be used on the app session.

        )

        )

      } else {

          ),

                } else {

                }

              }

            )

              ),

            )

          }

        )

      }

        )

      )

    })

    # manually trigger bookmarking because of the problems reported on windows with bookmarkButton in teal

    })

  })

}

#' @rdname module_bookmark_manager

get_bookmarking_option <- function() {

  }

}

#' @rdname module_bookmark_manager

need_bookmarking <- function(modules) {

  ))

}

# utilities ----

#' Restore value from bookmark.

#'

#' Get value from bookmark or return default.

#'

#' Bookmarks can store not only inputs but also arbitrary values.

#' These values are stored by `onBookmark` callbacks and restored by `onBookmarked` callbacks,

#' and they are placed in the `values` environment in the `session$restoreContext` field.

#' Using `teal_data_module` makes it impossible to run the callbacks

#' because the app becomes ready before modules execute and callbacks are registered.

#' In those cases the stored values can still be recovered from the `session` object directly.

#'

#' Note that variable names in the `values` environment are prefixed with module name space names,

#' therefore, when using this function in modules, `value` must be run through the name space function.

#'

#' @param value (`character(1)`) name of value to restore

#' @param default fallback value

#'

#' @return

#' In an application restored from a server-side bookmark,

#' the variable specified by `value` from the `values` environment.

#' Otherwise `default`.

#'

#' @keywords internal

#'

restoreValue <- function(value, default) { # nolint: object_name.

  } else {

  }

}

#' Compare bookmarks.

#'

#' Test if two bookmarks store identical state.

#'

#' `input` environments are compared one variable at a time and if not identical,

#' values in both bookmarks are reported. States of `datatable`s are stripped

#' of the `time` element before comparing because the time stamp is always different.

#' The contents themselves are not printed as they are large and the contents are not informative.

#' Elements present in one bookmark and absent in the other are also reported.

#' Differences are printed as messages.

#'

#' `values` environments are compared with `all.equal`.

#'

#' @section How to use:

#' Open an application, change relevant inputs (typically, all of them), and create a bookmark.

#' Then open that bookmark and immediately create a bookmark of that.

#' If restoring bookmarks occurred properly, the two bookmarks should store the same state.

#'

#'

#' @param book1,book2 bookmark directories stored in `shiny_bookmarks/`;

#'                    default to the two most recently modified directories

#'

#' @return

#' Invisible `NULL` if bookmarks are identical or if there are no bookmarks to test.

#' `FALSE` if inconsistencies are detected.

#'

#' @keywords internal

#'

bookmarks_identical <- function(book1, book2) {

  }

    }

  } else {

  }

    }

  }

  }

      }

    }

  }

      }

    }

  }

  }

}

# Replacement for [base::rapply] which doesn't handle NULL values - skips the evaluation

# of the function and returns NULL for given element.

rapply2 <- function(x, f) {

  } else {

  }

}

#' Send input validation messages to output

#'

#' Captures messages from `InputValidator` objects and collates them

#' into one message passed to `validate`.

#'

#' `shiny::validate` is used to withhold rendering of an output element until

#' certain conditions are met and to print a validation message in place

#' of the output element.

#' `shinyvalidate::InputValidator` allows to validate input elements

#' and to display specific messages in their respective input widgets.

#' `validate_inputs` provides a hybrid solution.

#' Given an `InputValidator` object, messages corresponding to inputs that fail validation

#' are extracted and placed in one validation message that is passed to a `validate`/`need` call.

#' This way the input `validator` messages are repeated in the output.

#'

#' The `...` argument accepts any number of `InputValidator` objects

#' or a nested list of such objects.

#' If `validators` are passed directly, all their messages are printed together

#' under one (optional) header message specified by `header`. If a list is passed,

#' messages are grouped by `validator`. The list's names are used as headers

#' for their respective message groups.

#' If neither of the nested list elements is named, a header message is taken from `header`.

#'

#' @param ... either any number of `InputValidator` objects

#'            or an optionally named, possibly nested `list` of `InputValidator`

#'            objects, see `Details`

#' @param header (`character(1)`) generic validation message; set to NULL to omit

#'

#' @return

#' Returns NULL if the final validation call passes and a `shiny.silent.error` if it fails.

#'

#' @seealso [`shinyvalidate::InputValidator`], [`shiny::validate`]

#'

#'

#' @examplesShinylive

#' library(teal)

#' interactive <- function() TRUE

#' {{ next_example }}

#' @examplesIf require("shinyvalidate")

#' library(shiny)

#' library(shinyvalidate)

#'

#' ui <- fluidPage(

#'   selectInput("method", "validation method", c("sequential", "combined", "grouped")),

#'   sidebarLayout(

#'     sidebarPanel(

#'       selectInput("letter", "select a letter:", c(letters[1:3], LETTERS[4:6])),

#'       selectInput("number", "select a number:", 1:6),

#'       tags$br(),

#'       selectInput("color", "select a color:",

#'         c("black", "indianred2", "springgreen2", "cornflowerblue"),

#'         multiple = TRUE

#'       ),

#'       sliderInput("size", "select point size:",

#'         min = 0.1, max = 4, value = 0.25

#'       )

#'     ),

#'     mainPanel(plotOutput("plot"))

#'   )

#' )

#'

#' server <- function(input, output) {

#'   # set up input validation

#'   iv <- InputValidator$new()

#'   iv$add_rule("letter", sv_in_set(LETTERS, "choose a capital letter"))

#'   iv$add_rule("number", function(x) {

#'     if (as.integer(x) %% 2L == 1L) "choose an even number"

#'   })

#'   iv$enable()

#'   # more input validation

#'   iv_par <- InputValidator$new()

#'   iv_par$add_rule("color", sv_required(message = "choose a color"))

#'   iv_par$add_rule("color", function(x) {

#'     if (length(x) > 1L) "choose only one color"

#'   })

#'   iv_par$add_rule(

#'     "size",

#'     sv_between(

#'       left = 0.5, right = 3,

#'       message_fmt = "choose a value between {left} and {right}"

#'     )

#'   )

#'   iv_par$enable()

#'

#'   output$plot <- renderPlot({

#'     # validate output

#'     switch(input[["method"]],

#'       "sequential" = {

#'         validate_inputs(iv)

#'         validate_inputs(iv_par, header = "Set proper graphical parameters")

#'       },

#'       "combined" = validate_inputs(iv, iv_par),

#'       "grouped" = validate_inputs(list(

#'         "Some inputs require attention" = iv,

#'         "Set proper graphical parameters" = iv_par

#'       ))

#'     )

#'

#'     plot(faithful$eruptions ~ faithful$waiting,

#'       las = 1, pch = 16,

#'       col = input[["color"]], cex = input[["size"]]

#'     )

#'   })

#' }

#'

#' if (interactive()) {

#'   shinyApp(ui, server)

#' }

#'

#' @export

#'

validate_inputs <- function(..., header = "Some inputs require attention") {

  } else {

  }

}

### internal functions

#' @noRd

#' @keywords internal

# recursive object type test

# returns logical of length 1

is_validators <- function(x) {

}

#' @noRd

#' @keywords internal

# test if an InputValidator object is enabled

# returns logical of length 1

# official method requested at https://github.com/rstudio/shinyvalidate/issues/64

validator_enabled <- function(x) {

}

#' Recursively extract messages from validator list

#' @return A character vector or a list of character vectors, possibly nested and named.

#' @noRd

#' @keywords internal

extract_validator <- function(iv, header) {

  } else {

  }

}

#' Collate failing messages from validator.

#' @return `list`

#' @noRd

#' @keywords internal

gather_messages <- function(iv) {

  } else {

  }

}

#' Add optional header to failing messages

#' @noRd

#' @keywords internal

add_header <- function(messages, header = "") {

  }

}

#' Recursively check if the object contains a named list

#' @noRd

#' @keywords internal

any_names <- function(x) {

    } else {

    }

  )

}

#' Data Module for teal

#'

#' This module manages the `data` argument for `srv_teal`. The `teal` framework uses [teal.data::teal_data()],

#' which can be provided in various ways:

#' 1. Directly as a [teal.data::teal_data()] object. This will automatically convert it into a `reactive` `teal_data`.

#' 2. As a `reactive` object that returns a [teal.data::teal_data()] object.

#'

#' @details

#' ## Reactive `teal_data`:

#'

#' The data in the application can be reactively updated, prompting [srv_teal()] to rebuild the

#' content accordingly. There are two methods for creating interactive `teal_data`:

#' 1. Using a `reactive` object provided from outside the `teal` application. In this scenario,

#' reactivity is controlled by an external module, and `srv_teal` responds to changes.

#' 2. Using [teal_data_module()], which is embedded within the `teal` application, allowing data to

#' be resubmitted by the user as needed.

#'

#' Since the server of [teal_data_module()] must return a `reactive` `teal_data` object, both

#' methods (1 and 2) produce the same reactive behavior within a `teal` application. The distinction

#' lies in data control: the first method involves external control, while the second method

#' involves control from a custom module within the app.

#'

#' For more details, see [`module_teal_data`].

#'

#' @inheritParams module_teal

#'

#' @return A `reactive` object that returns:

#' Output of the `data`. If `data` fails then returned error is handled (after [tryCatch()]) so that

#' rest of the application can respond to this respectively.

#'

#' @rdname module_init_data

#' @name module_init_data

#' @keywords internal

NULL

#' @rdname module_init_data

ui_init_data <- function(id) {

  )

}

#' @rdname module_init_data

srv_init_data <- function(id, data) {

    }

    })

    # We want to exclude teal_data_module elements from bookmarking as they might have some secrets

            )

          ),