#' Data correlations evaluation module
#'
#' @param id Module id
#' @param ... additional UI elements to show before the table overview
#'
#' @name data-missings
#' @returns Shiny ui module
#' @export
data_missings_ui <- function(id, ...) {
  ns <- shiny::NS(id)

  list(bslib::layout_sidebar(
    uiOutput(outputId = ns("feedback")),
    sidebar = bslib::sidebar(
      bslib::accordion(
        id = ns("acc_mis"),
        open = "acc_chars",
        multiple = FALSE,
        bslib::accordion_panel(
          value = "acc_pan_mis",
          title = "Settings",
          icon = phosphoricons::ph("gear"),
          # icon = bsicons::bs_icon("gear"),
          shiny::conditionalPanel(
            condition = "output.missings == true",
            shiny::uiOutput(ns("missings_method")),
            shiny::uiOutput(ns("missings_var")),
            ns = ns
          ),
          shiny::helpText(
            i18n$t(
              "Evaluate missingness by either comparing missing values across variables (optionally grouped by af categorical or dichotomous variable) or compare variables grouped by the missing status (missing or not) of an outcome variable. If there is a significant difference i the missingness, this may cause a bias in you data and should be considered carefully interpreting the data and analyses as data may not be missing at random."
            )
          ),
          shiny::br(),
          shiny::actionButton(
            inputId = ns("act_miss"),
            label = i18n$t("Evaluate"),
            width = "100%",
            icon = phosphoricons::ph("calculator"),
            # icon = shiny::icon("calculator"),
            disabled = TRUE
          )
        ),
        do.call(bslib::accordion_panel, c(
          list(
            title = "Download",
            icon = phosphoricons::ph("download-simple")
            # icon = bsicons::bs_icon("file-earmark-arrow-down")
          ),
          table_download_ui(id = ns("tbl_dwn"), title = NULL)
        ))
      )
    ),
    ...,
    gt::gt_output(outputId = ns("missings_table"))
  ))
}

## This should really just be rebuild to only contain a function

#'
#' @param data data
#' @param output.format output format
#'
#' @name data-missings
#' @returns shiny server module
#' @export
data_missings_server <- function(id, data, max_level = 20, ...) {
  shiny::moduleServer(
    id = id,
    module = function(input, output, session) {
      ns <- session$ns

      datar <- if (is.reactive(data))
        data
      else
        reactive(data)

      rv <- shiny::reactiveValues(data = NULL,
                                  table = NULL,
                                  feedback = NULL)

      ## Case with no missings

      info_alert <- shinyWidgets::alert(
        status = "info",
        phosphoricons::ph("question"),
        i18n$t("You have provided a complete dataset with no missing values.")
      )

      output$missings <- shiny::reactive({
        # shiny::req(data())
        any(is.na(datar()))
      })
      shiny::outputOptions(output, "missings", suspendWhenHidden = FALSE)

      shiny::observeEvent(list(datar(), input$missings_method, input$missings_var),
                   {
                     # shiny::req(data())
                     # browser()
                     if (!any(is.na(datar()))) {
                       rv$feedback <- info_alert
                       shiny::updateActionButton(inputId = "act_miss", disabled = TRUE)
                       rv$table <- NULL
                       output$missings_table <- gt::render_gt({ NULL })
                     } else {
                       rv$feedback <- NULL
                       shiny::updateActionButton(inputId = "act_miss", disabled = FALSE)
                     }
                   },ignoreInit = TRUE)


      output$feedback <- renderUI(rv$feedback)

      ## Notes
      ##
      ## Code export is still missing
      ## Direct table export would be nice

      shiny::observe(output$missings_method <- shiny::renderUI({
        shiny::req(datar())
        vectorSelectInput(
          inputId = ns("missings_method"),
          label = i18n$t("Analysis method for missingness overview"),
          choices = setNames(c("predictors", "outcome"), c(
            i18n$t("Overview of missings across variables"),
            i18n$t(
              "Overview of difference in variables by missing status in outcome"
            )
          ))
        )
      }))

      shiny::observe({
        output$missings_var <- shiny::renderUI({
          shiny::req(datar())
          shiny::req(input$missings_method)
          # browser()
          if (input$missings_method == "predictors") {
            label <- i18n$t("Select a variable for grouped overview")
            df <- data_type_filter(datar(), type = c("categorical", "dichotomous"))
            col_subset <- c("none", names(df))
          } else {
            label <- i18n$t("Select outcome variable for overview")
            df <- datar()[apply(datar(), 2, anyNA)]
            col_subset <- names(df)
          }
          columnSelectInput(
            inputId = ns("missings_var"),
            label = label,
            data = df,
            col_subset = col_subset,
            none_label = i18n$t("No variable")
          )
        })
      })


      shiny::observeEvent(list(input$act_miss), {
        shiny::req(datar())
        shiny::req(input$missings_var)
        # browser()
        df_tbl <- datar()
        by_var <- input$missings_var

        parameters <- list(
          by_var = by_var,
          max_level = max_level,
          type = input$missings_method
        )

        tryCatch({
          shiny::withProgress(message = i18n$t("Calculating. Hold tight for a moment.."), {
            out <- do.call(compare_missings, modifyList(parameters, list(data = df_tbl)))
          })
        }, error = function(err) {
          showNotification(paste0("Error: ", err), type = "error")
        })

        if (is.null(input$missings_var) ||
            input$missings_var == "" ||
            !input$missings_var %in% names(datar()) ||
            input$missings_var == "none") {
          # if (is.null(variabler()) || variabler() == "" || !variabler() %in% names(data()) || variabler() == "none") {
          # tbl <- rv$data()
          if (anyNA(datar())) {
            if (input$missings_method == "predictors") {
              title <- i18n$t("Overview of missing observations")
            } else {
              title <- i18n$t("No outcome measure chosen")
            }
          } else {
            title <- i18n$t("No missing observations")
          }
        } else {
          ## Due to reactivity, the table updates too quickly. this mitigates that issue..
          if (input$missings_method == "predictors") {
            title <- glue::glue(
              i18n$t(
                "Missing observations across variables grouped by **'{input$missings_var}'**"
              )
            )
          } else {
            title <- glue::glue(
              i18n$t(
                "Differences by missing vs non-missing observations in **'{input$missings_var}'**"
              )
            )
          }
        }

        attr(out, "tbl_title") <- title

        rv$data <- shiny::reactive(out)
      })

      shiny::observeEvent(list(
        # input$act_miss
        rv$data
      ), {
        output$missings_table <- gt::render_gt({
          shiny::req(rv$data)
          # shiny::req(input$missings_var)
          # browser()
          if ("p.value" %in% names(rv$data()[["table_body"]])) {
            tbl <- rv$data() |>
              gtsummary::bold_p()
          } else {
            tbl <- rv$data()
          }


          out <- tbl |>
            gtsummary::as_gt() |>
            gt::tab_header(title = gt::md(attr(tbl, "tbl_title")))

          attr(out, "strat_var") <- input$missings_var

          rv$table <- out

          out
        })
      })


      table_download_server(
        id = "tbl_dwn",
        data = shiny::reactive(rv$table),
        file_name = "missings_table"
      )

      return(shiny::reactive(rv$table))
    }
  )
}


missing_demo_app <- function() {
  ui <- do.call(bslib::page, c(
    list(
      title = i18n$t("Missings"),
      icon = bsicons::bs_icon("x-circle")
    ),
    data_missings_ui(id = "data"),
    gt::gt_output("table_p")
  ))
  server <- function(input, output, session) {
    data_demo <- mtcars
    data_demo[sample(1:32, 10), "cyl"] <- NA
    data_demo[sample(1:32, 8), "vs"] <- NA

    rv <- shiny::reactiveValues(table = NULL)

    rv$table <- data_missings_server(id = "data", data = data_demo)

    output$table_p <- gt::render_gt({
      rv$table
    })

    # visual_summary_server(id = "visual", data = data_demo)

    # observeEvent(input$modal_missings, {
    #   tryCatch(
    #     {
    #       modal_visual_summary(id = "visual")
    #     },
    #     error = function(err) {
    #       showNotification(paste0("We encountered the following error browsing your data: ", err), type = "err")
    #     }
    #   )
    # })
  }
  shiny::shinyApp(ui, server)
}

# missing_demo_app()

#' Pairwise comparison of missings across covariables
#'
#' @param data data frame
#' @param by_var variable to stratify by missingness
#'
#' @returns gtsummary list object
#' @export
#'
compare_missings <- function(data,
                             by_var,
                             max_level = 20,
                             type = c("predictors", "outcome")) {
  type <- match.arg(type)

  if (!is.null(by_var) && by_var != "" && by_var %in% names(data)) {
    data <- data |>
      lapply(\(.x) {
        if (is.factor(.x)) {
          cut_var(.x, breaks = 20, type = "top")
        } else {
          .x
        }
      }) |>
      dplyr::bind_cols()

    if (type == "predictors") {
      data <- missings_logic_across(data, exclude = by_var)
    } else {
      data[[by_var]] <- ifelse(is.na(data[[by_var]]), "Missing", "Non-missing")
    }

    out <- gtsummary::tbl_summary(data, by = by_var) |>
      gtsummary::add_p()
  } else {
    if (type == "predictors") {
      data <- missings_logic_across(data)
    }

    out <- gtsummary::tbl_summary(data)
  }

  out
}

#' Converting all variables to logicals by missing status
#'
#' @param data data
#' @param exclude character vector of variable names to be excluded
#'
#' @returns data frame
#' @export
#'
#' @examples
#' mtcars |> missings_logic_across("cyl")
#' ## gtsummary::trial |>
#' ##   missings_logic_across() |>
#' ##   gtsummary::tbl_summary()
missings_logic_across <- function(data, exclude = NULL) {
  # This function includes a way to preserve variable labels
  with_labels(data,{
  names(data) |>
    lapply(\(.x) {
      if (!.x %in% exclude) {
        is.na(data[[.x]])
      } else {
        data[[.x]]
      }
    }) |>
    dplyr::bind_cols(.name_repair = "unique_quiet") |>
    setNames(names(data))
  })
}