#' Calls all `modules`

#'

#' Modules create navigation bar with drop-down menu and tab content. Each `teal_module` is called recursively

#' according to the structure of `modules` argument. This is a custom module which utilizes shiny/Bootstrap

#' `.nav` class. `modules` are called with an `id` derived from `teal_module`'s label and labels of its

#' ancestors (if any).

#'

#' ### Functions

#'

#' - `ui/srv_teal_module` - wrapper module which links drop-down buttons with modules panels.

#'   Here `input$active_module_id` is instantiated.

#' - `.ui/srv_teal_module` - recursive S3 method which calls each module

#' - `.teal_navbar_append` - wrapper for [htmltools::tagAppendChild()] to add any element to navigation bar.

#' - `.teal_navbar_insert_ui` - wrapper for [shiny::insertUI()] to insert any element to navigation bar.

#' - `.teal_navbar_menu` - UI function to create a drop-down menu for navigation bar.

#'

#' ### Utilizing `.nav` class

#'

#' No extra `javascript` or server functionality were introduced to have navigation buttons toggle between

#' tab panels. This works thanks to `.nav` container which links `.nav-link` buttons `href = #<module id>`

#' attribute with `.tab-pane`'s `id = <module id>` (see ``.ui_teal_module.teal_module`).

#'

#' ### Initialization and isolation of the `teal_module`(s)

#'

#' Modules are initialized only when they are active. This speeds up app initialization and on

#' startup only the first module is activated and its outputs are calculated.

#' Only the active module is listening to reactive events. This way, modules are isolated and only

#' one can run at any given time. This makes the app more efficient by reducing unnecessary

#' computations on server side.

#'

#' @name module_teal_module

#'

#' @inheritParams module_teal

#'

#' @param data (`reactive` returning `teal_data`)

#'

#' @param slices_global (`reactiveVal` returning `modules_teal_slices`)

#'   see [`module_filter_manager`]

#'

#' @param datasets (`reactive` returning `FilteredData` or `NULL`)

#'  When `datasets` is passed from the parent module (`srv_teal`) then `dataset` is a singleton

#'  which implies the filter-panel to be "global". When `NULL` then filter-panel is "module-specific".

#'

#' @param reporter (`Reporter`, singleton)

#'  Stores reporter-cards appended in the server of `teal_module`.

#'

#' @param data_load_status (`reactive` returning `character(1)`)

#'  Determines action dependent on a data loading status:

#'  - `"ok"` when `teal_data` is returned from the data loading.

#'  - `"teal_data_module failed"` when [teal_data_module()] didn't return `teal_data`. Disables tab buttons.

#'  - `"external failed"` when a `reactive` passed to `srv_teal(data)` didn't return `teal_data`. Hides the whole tab

#'    panel.

#'

#' @param active_module_id (`reactive` returning `character(1)`)

#'   `id` of the currently active module. This helps to determine which module can listen to reactive events.

#'

#' @return

#' Output of currently active module.

#' - `srv_teal_module.teal_module` returns `reactiveVal` containing output of the called module.

#' - `srv_teal_module.teal_modules` returns output of modules in a list following the hierarchy of `modules`

#'

#' @keywords internal

NULL

#' @rdname module_teal_module

ui_teal_module <- function(id, modules) {

  )

    ),

      )

    ),

  )

}

#' @rdname module_teal_module

srv_teal_module <- function(id,

                            data,

                            modules,

                            datasets = NULL,

                            slices_global,

                            reporter = teal.reporter::Reporter$new(),

                            data_load_status = reactive("ok")) {

    )

  })

}

#' @rdname module_teal_module

.teal_navbar_append <- function(navbar, child) {

}

#' @rdname module_teal_module

.teal_navbar_insert_ui <- function(ui, where = "afterBegin", session = getDefaultReactiveDomain()) {

  )

}

#' @rdname module_teal_module

.teal_navbar_menu <- function(..., id = NULL, label = NULL, class = NULL, icon = NULL) {

    ),

    )

  )

}

#' @rdname module_teal_module

.ui_teal_module <- function(id, modules, active_module_id) {

}

#' @rdname module_teal_module

#' @export

.ui_teal_module.default <- function(id, modules, active_module_id) {

}

#' @rdname module_teal_module

#' @export

.ui_teal_module.teal_modules <- function(id, modules, active_module_id) {

  )

    ),

  )

}

#' @rdname module_teal_module

#' @export

.ui_teal_module.teal_module <- function(id, modules, active_module_id) {

        )

      )

    ),

      ),

    )

  )

      # `nav-link` is required to mimic bslib tab panel.

    )

  )

                      )

                    )

                  )

                ),

                ),

                          )

                        )

                      )

                    )

                  )

                }

              )

            ),

          ),

            ),

            ),

              )

            }

          ),

                "

                  });

                ",

              )

            )

          )

        )

      } else {

      }

    )

  )

}

#' @rdname module_teal_module

.srv_teal_module <- function(id,

                             data,

                             modules,

                             datasets = NULL,

                             slices_global,

                             reporter = teal.reporter::Reporter$new(),

                             data_load_status = reactive("ok"),

                             active_module_id = reactive(TRUE)) {

}

#' @rdname module_teal_module

#' @export

.srv_teal_module.default <- function(id,

                                     data,

                                     modules,

                                     datasets = NULL,

                                     slices_global,

                                     reporter = teal.reporter::Reporter$new(),

                                     data_load_status = reactive("ok"),

                                     active_module_id = reactive(TRUE)) {

}

#' @rdname module_teal_module

#' @export

.srv_teal_module.teal_modules <- function(id,

                                          data,

                                          modules,

                                          datasets = NULL,

                                          slices_global,

                                          reporter = teal.reporter::Reporter$new(),

                                          data_load_status = reactive("ok"),

                                          active_module_id = reactive(TRUE)) {

        )

      },

    )

  })

}

#' @rdname module_teal_module

#' @export

.srv_teal_module.teal_module <- function(id,

                                         data,

                                         modules,

                                         datasets = NULL,

                                         slices_global,

                                         reporter = teal.reporter::Reporter$new(),

                                         data_load_status = reactive("ok"),

                                         active_module_id = reactive(TRUE)) {

    })

    })

      })

    }

    # manage module filters on the module level

    # important:

    #   filter_manager_module_srv needs to be called before filter_panel_srv

    #   Because available_teal_slices is used in FilteredData$srv_available_slices (via srv_filter_panel)

    #   and if it is not set, then it won't be available in the srv_filter_panel

      )

      )

      })

        } else {

        }

      })

      })

      )

      })

      })

      })

      # Call modules.

          }

        )

      } else {

        # Report previewer must be initiated on app start for report cards to be included in bookmarks.

        # When previewer is delayed, cards are bookmarked only if previewer has been initiated (visited).

      }

    })

  })

}

# This function calls a module server function.

.call_teal_module <- function(modules, datasets, data, reporter) {

  # collect arguments to run teal_module

  }

  }

  }

  }

  } else {

  }

}

.resolve_module_datanames <- function(data, modules) {

  } else {

    )

  }

}

#' Calls expression when condition is met

#'

#' Function postpones `handlerExpr` to the moment when `eventExpr` (condition) returns `TRUE`,

#' otherwise nothing happens.

#' @param eventExpr A (quoted or unquoted) logical expression that represents the event;

#' this can be a simple reactive value like input$click, a call to a reactive expression

#' like dataset(), or even a complex expression inside curly braces.

#' @param ... additional arguments passed to `observeEvent` with the exception of `eventExpr` that is not allowed.

#' @inheritParams shiny::observeEvent

#'

#' @return An observer.

#'

#' @keywords internal

.call_once_when <- function(eventExpr, # nolint: object_name.

                            handlerExpr, # nolint: object_name.

                            event.env = parent.frame(), # nolint: object_name.

                            handler.env = parent.frame(), # nolint: object_name.

                            ...) {

  # When `condExpr` is TRUE, then `handlerExpr` is evaluated once.

    }

  })

    ...

  )

}

.modules_breadcrumb <- function(module) {

  )

}

#' Generate lockfile for application's environment reproducibility

#'

#' @inheritParams module_teal

#' @param lockfile_path (`character`) path to the lockfile.

#'

#' @section Different ways of creating lockfile:

#' `teal` leverages [renv::snapshot()], which offers multiple methods for lockfile creation.

#'

#' - **Working directory lockfile**: `teal`, by default, will create an `implicit` type lockfile that uses

#' `renv::dependencies()` to detect all R packages in the current project's working directory.

#' - **`DESCRIPTION`-based lockfile**: To generate a lockfile based on a `DESCRIPTION` file in your working

#' directory, set `renv::settings$snapshot.type("explicit")`. The naming convention for `type` follows

#' `renv::snapshot()`. For the `"explicit"` type, refer to `renv::settings$package.dependency.fields()` for the

#' `DESCRIPTION` fields included in the lockfile.

#' - **Custom files-based lockfile**: To specify custom files as the basis for the lockfile, set

#' `renv::settings$snapshot.type("custom")` and configure the `renv.snapshot.filter` option.

#'

#' @section lockfile usage:

#' After creating the lockfile, you can restore the application's environment using `renv::restore()`.

#'

#' @seealso [renv::snapshot()], [renv::restore()].

#'

#' @return `NULL`

#'

#' @name module_teal_lockfile

#' @rdname module_teal_lockfile

#'

#' @keywords internal

NULL

#' @rdname module_teal_lockfile

ui_teal_lockfile <- function(id) {

  )

}

#' @rdname module_teal_lockfile

srv_teal_lockfile <- function(id) {

        },

        },

      )

    }

    }

      }

    })

    }

    }

    }

      )

    }

    }

    # - Will be run only if the lockfile doesn't exist (see the if-s above)

    # - We render to the tempfile because the process might last after session is closed and we don't

    #   want to make a "teal_app.renv" then. This is why we copy only during active session.

            }

          }

        } else {

        }

      }

    })

  })

}

utils::globalVariables(c("opts", "sysenv", "libpaths", "wd", "lockfilepath", "run")) # needed for mirai call

#' @rdname module_teal_lockfile

.teal_lockfile_process_invoke <- function(lockfile_path) {

      {

      },

    )

  })

    }

  })

  })

}

#' @rdname module_teal_lockfile

.renv_snapshot <- function(lockfile_path) {

    )

  )

}

#' @rdname module_teal_lockfile

.is_lockfile_deps_installed <- function() {

}

#' @rdname module_teal_lockfile

.is_disabled_lockfile_scenario <- function() {

    (

}

#' Filter state snapshot management

#'

#' Capture and restore snapshots of the global (app) filter state.

#'

#' This module introduces snapshots: stored descriptions of the filter state of the entire application.

#' Snapshots allow the user to save the current filter state of the application for later use in the session,

#' as well as to save it to file in order to share it with an app developer or other users,

#' who in turn can upload it to their own session.

#'

#' The snapshot manager is accessed with the camera icon in the tabset bar.

#' At the beginning of a session it presents three icons: a camera, an upload, and an circular arrow.

#' Clicking the camera captures a snapshot, clicking the upload adds a snapshot from a file

#' and applies the filter states therein, and clicking the arrow resets initial application state.

#' As snapshots are added, they will show up as rows in a table and each will have a select button and a save button.

#'

#' @section Server logic:

#' Snapshots are basically `teal_slices` objects, however, since each module is served by a separate instance

#' of `FilteredData` and these objects require shared state, `teal_slice` is a `reactiveVal` so `teal_slices`

#' cannot be stored as is. Therefore, `teal_slices` are reversibly converted to a list of lists representation

#' (attributes are maintained).

#'

#' Snapshots are stored in a `reactiveVal` as a named list.

#' The first snapshot is the initial state of the application and the user can add a snapshot whenever they see fit.

#'

#' For every snapshot except the initial one, a piece of UI is generated that contains

#' the snapshot name, a select button to restore that snapshot, and a save button to save it to a file.

#' The initial snapshot is restored by a separate "reset" button.

#' It cannot be saved directly but a user is welcome to capture the initial state as a snapshot and save that.

#'

#' @section Snapshot mechanics:

#' When a snapshot is captured, the user is prompted to name it.

#' Names are displayed as is but since they are used to create button ids,

#' under the hood they are converted to syntactically valid strings.

#' New snapshot names are validated so that their valid versions are unique.

#' Leading and trailing white space is trimmed.

#'

#' The module can read the global state of the application from `slices_global` and `mapping_matrix`.

#' The former provides a list of all existing `teal_slice`s and the latter says which slice is active in which module.

#' Once a name has been accepted, `slices_global` is converted to a list of lists - a snapshot.

#' The snapshot contains the `mapping` attribute of the initial application state

#' (or one that has been restored), which may not reflect the current one,

#' so `mapping_matrix` is transformed to obtain the current mapping, i.e. a list that,

#' when passed to the `mapping` argument of [teal_slices()], would result in the current mapping.

#' This is substituted as the snapshot's `mapping` attribute and the snapshot is added to the snapshot list.

#'

#' To restore app state, a snapshot is retrieved from storage and rebuilt into a `teal_slices` object.

#' Then state of all `FilteredData` objects (provided in `datasets`) is cleared

#' and set anew according to the `mapping` attribute of the snapshot.

#' The snapshot is then set as the current content of `slices_global`.

#'

#' To save a snapshot, the snapshot is retrieved and reassembled just like for restoring,

#' and then saved to file with [slices_store()].

#'

#' When a snapshot is uploaded, it will first be added to storage just like a newly created one,

#' and then used to restore app state much like a snapshot taken from storage.

#' Upon clicking the upload icon the user will be prompted for a file to upload

#' and may choose to name the new snapshot. The name defaults to the name of the file (the extension is dropped)

#' and normal naming rules apply. Loading the file yields a `teal_slices` object,

#' which is disassembled for storage and used directly for restoring app state.

#'

#' @section Transferring snapshots:

#' Snapshots uploaded from disk should only be used in the same application they come from,

#' _i.e._ an application that uses the same data and the same modules.

#' To ensure this is the case, `init` stamps `teal_slices` with an app id that is stored in the `app_id` attribute of

#' a `teal_slices` object. When a snapshot is restored from file, its `app_id` is compared to that

#' of the current app state and only if the match is the snapshot admitted to the session.

#'

#' @section Bookmarks:

#' An `onBookmark` callback creates a snapshot of the current filter state.

#' This is done on the app session, not the module session.

#' (The snapshot will be retrieved by `module_teal` in order to set initial app state in a restored app.)

#' Then that snapshot, and the previous snapshot history are dumped into the `values.rds` file in `<bookmark_dir>`.

#'

#' @param id (`character(1)`) `shiny` module instance id.

#' @param slices_global (`reactiveVal`) that contains a `teal_slices` object

#'                      containing all `teal_slice`s existing in the app, both active and inactive.

#'

#' @return `list` containing the snapshot history, where each element is an unlisted `teal_slices` object.

#'

#' @name module_snapshot_manager

#' @rdname module_snapshot_manager

#'

#' @author Aleksander Chlebowski

#' @keywords internal

NULL

#' @rdname module_snapshot_manager

ui_snapshot_manager_panel <- function(id) {

  )

}

#' @rdname module_snapshot_manager

srv_snapshot_manager_panel <- function(id, slices_global) {

        )

      )

    })

  })

}

#' @rdname module_snapshot_manager

ui_snapshot_manager <- function(id) {

      ),

      ),

      ),

    ),

  )

}

#' @rdname module_snapshot_manager

srv_snapshot_manager <- function(id, slices_global) {

    # Set up bookmarking callbacks ----

    # Register bookmark exclusions (all buttons and text fields).

    ))

    # Add snapshot history to bookmark.

    })

    # Track global filter states ----

      # Restore directly from bookmarked state, if applicable.

      )

    })

    # Snapshot current application state ----

    # Name snapshot.

            ),

            )

          ),

        )

      )

    })

    # Store snapshot.

        )

        )

      } else {

        # Reopen filter manager modal by clicking button in the main application.

      }

    })

    # Upload a snapshot file ----

    # Select file.

          ),

            ),

              )

            )

          )

        )

      )

    })

    })

    # Store new snapshot to list and restore filter states.

      }

        )

      } else {

        # Restore snapshot and verify app compatibility.

          )

          )

        } else {

          # Add to snapshot history.

          ### Begin simplified restore procedure. ###

          ### End  simplified restore procedure. ###

        }

      }

    })

    # Apply newly added snapshot.

    # Restore initial state ----

      ### Begin restore procedure. ###

      ### End restore procedure. ###

    })

    # Build snapshot table ----

    # Create UI elements and server logic for the snapshot table.

    # Observers must be tracked to avoid duplication and excess reactivity.

    # Remaining elements are tracked likewise for consistency and a slight speed margin.

        # Observer for restoring snapshot.

            ### Begin restore procedure. ###

            ### End restore procedure. ###

          })

        }

        # Create handler for downloading snapshot.

            },

            }

          )

        }

        # Create a row for the snapshot table.

            ),

            )

          )

        }

      })

    })

    # Create table to display list of snapshots and their actions.

        )

      } else {

      }

    })

  })

}

# FilteredData ------

#' Drive a `teal` application

#'

#' Extension of the `shinytest2::AppDriver` class with methods for

#' driving a teal application for performing interactions for `shinytest2` tests.

#'

#' @keywords internal

#'

TealAppDriver <- R6::R6Class( # nolint: object_name.

  "TealAppDriver",

  cloneable = FALSE,

  inherit = {

    lapply(c("testthat", "shinytest2", "rvest"), function(.x, use_testthat) {

      if (!requireNamespace(.x, quietly = TRUE)) {

        if (use_testthat) {

          testthat::skip(sprintf("%s is not installed", .x))

        } else {

          stop("Please install '", .x, "' package to use this class.", call. = FALSE)

        }

      }

    }, use_testthat = requireNamespace("testthat", quietly = TRUE) && testthat::is_testing())

    shinytest2::AppDriver

  },

  # public methods ----

  public = list(

    #' @description

    #' Initialize a `TealAppDriver` object for testing a `teal` application.

    #'

    #' @param data,modules,filter arguments passed to `init`

    #' @param title_args,header,footer,landing_popup_args to pass into the modifier functions.

    #' @param timeout (`numeric`) Default number of milliseconds for any timeout or

    #' timeout_ parameter in the `TealAppDriver` class.

    #' Defaults to 20s.

    #'

    #' See [`shinytest2::AppDriver`] `new` method for more details on how to change it

    #' via options or environment variables.

    #' @param load_timeout (`numeric`) How long to wait for the app to load, in ms.

    #' This includes the time to start R. Defaults to 100s.

    #'

    #' See [`shinytest2::AppDriver`] `new` method for more details on how to change it

    #' via options or environment variables

    #' @param ... Additional arguments to be passed to `shinytest2::AppDriver$new`

    #'

    #'

    #' @return  Object of class `TealAppDriver`

    initialize = function(data,

                          modules,

                          filter = teal_slices(),

                          title_args = list(),

                          header = tags$p(),

                          footer = tags$p(),

                          landing_popup_args = NULL,

                          timeout = rlang::missing_arg(),

                          load_timeout = rlang::missing_arg(),

                          ...) {

        ),

      )

      ) |>

        )

        )

        )

      }

      # Default timeout is hardcoded to 4s in shinytest2:::resolve_timeout

      # It must be set as parameter to the AppDriver

          ...

        )

      )

      # Check for minimum version of Chrome that supports the tests

      #  - Element.checkVisibility was added on 105

          "",

        ),

      )

      )

        )

      )

      # end od check

    },

    #' @description

    #' Append parent [`shinytest2::AppDriver`] `click` method with a call to `waif_for_idle()` method.

    #' @param ... arguments passed to parent [`shinytest2::AppDriver`] `click()` method.

    click = function(...) {

    },

    #' @description

    #' Check if the app has shiny errors. This checks for global shiny errors.

    #' Note that any shiny errors dependent on shiny server render will only be captured after the teal module tab

    #' is visited because shiny will not trigger server computations when the tab is invisible.

    #' So, navigate to the module tab you want to test before calling this function.

    #' Although, this catches errors hidden in the other module tabs if they are already rendered.

    expect_no_shiny_error = function() {

      )

    },

    #' @description

    #' Check if the app has no validation errors. This checks for global shiny validation errors.

    expect_no_validation_error = function() {

      )

    },

    #' @description

    #' Check if the app has validation errors. This checks for global shiny validation errors.

    expect_validation_error = function() {

      )

    },

    #' @description

    #' Set the input in the `teal` app.

    #'

    #' @param input_id (character) The shiny input id with it's complete name space.

    #' @param value The value to set the input to.

    #' @param ... Additional arguments to be passed to `shinytest2::AppDriver$set_inputs`

    #'

    #' @return The `TealAppDriver` object invisibly.

    set_input = function(input_id, value, ...) {

      )

    },

    #' @description

    #' Navigate the teal tabs in the `teal` app.

    #'

    #' @param tab (character) Labels of tabs to navigate to.

    #' Note: Make sure to provide unique labels for the tabs.

    #'

    #' @return The `TealAppDriver` object invisibly.

    navigate_teal_tab = function(tab) {

        )

      )

    },

    #' @description

    #' Get the active shiny name space for different components of the teal app.

    #'

    #' @return (`list`) The list of active shiny name space of the teal components.

    active_ns = function() {

      }

    },

    #' @description

    #' Get the active shiny name space for interacting with the module content.

    #'

    #' @return (`string`) The active shiny name space of the component.

    active_module_ns = function() {

      }

    },

    #' @description

    #' Get the active shiny name space bound with a custom `element` name.

    #'

    #' @param element `character(1)` custom element name.

    #'

    #' @return (`string`) The active shiny name space of the component bound with the input `element`.

    active_module_element = function(element) {

    },

    #' @description

    #' Get the text of the active shiny name space bound with a custom `element` name.

    #'

    #' @param element `character(1)` the text of the custom element name.

    #'

    #' @return (`string`) The text of the active shiny name space of the component bound with the input `element`.

    active_module_element_text = function(element) {

    },

    #' @description

    #' Get the active shiny name space for interacting with the filter panel.

    #'

    #' @return (`string`) The active shiny name space of the component.

    active_filters_ns = function() {

      }

    },

    #' @description

    #' Get the active shiny name space for interacting with the data-summary panel.

    #'

    #' @return (`string`) The active shiny name space of the data-summary component.

    active_data_summary_ns = function() {

      }

    },

    #' @description

    #' Get the active shiny name space bound with a custom `element` name.

    #'

    #' @param element `character(1)` custom element name.

    #'

    #' @return (`string`) The active shiny name space of the component bound with the input `element`.

    active_data_summary_element = function(element) {

    },

    #' @description

    #' Get the input from the module in the `teal` app.

    #' This function will only access inputs from the name space of the current active teal module.

    #'

    #' @param input_id (character) The shiny input id to get the value from.

    #'

    #' @return The value of the shiny input.

    get_active_module_input = function(input_id) {

    },

    #' @description

    #' Get the output from the module in the `teal` app.

    #' This function will only access outputs from the name space of the current active teal module.

    #'

    #' @param output_id (character) The shiny output id to get the value from.

    #'

    #' @return The value of the shiny output.

    get_active_module_output = function(output_id) {

    },

    #' @description

    #' Get the output from the module's `teal.widgets::table_with_settings` or `DT::DTOutput` in the `teal` app.

    #' This function will only access outputs from the name space of the current active teal module.

    #'

    #' @param table_id (`character(1)`) The id of the table in the active teal module's name space.

    #' @param which (integer) If there is more than one table, which should be extracted.

    #' By default it will look for  a table that is built using `teal.widgets::table_with_settings`.

    #'

    #' @return The data.frame with table contents.

    get_active_module_table_output = function(table_id, which = 1) {

      )

      } else {

      }

    },

    #' @description

    #' Get the output from the module's `teal.widgets::plot_with_settings` in the `teal` app.

    #' This function will only access plots from the name space of the current active teal module.

    #'

    #' @param plot_id (`character(1)`) The id of the plot in the active teal module's name space.

    #'

    #' @return The `src` attribute as `character(1)` vector.

    get_active_module_plot_output = function(plot_id) {

      )

    },

    #' @description

    #' Set the input in the module in the `teal` app.

    #' This function will only set inputs in the name space of the current active teal module.

    #'

    #' @param input_id (character) The shiny input id to get the value from.

    #' @param value The value to set the input to.

    #' @param ... Additional arguments to be passed to `shinytest2::AppDriver$set_inputs`

    #'

    #' @return The `TealAppDriver` object invisibly.

    set_active_module_input = function(input_id, value, ...) {