app.R

### CSES DATA PLAYGROUND
# Date: November 10th, 2025
# Author: Robert Vidigal, PhD
# Purpose: CSES Shiny Data Playground based on LAPOP Lab Data Playground
# Prev file: ./shiny_preprocessing.R
# Machine: Windows OS
# Status: On-going
# # -----------------------------------------------------------------------
### Data In:
# 1. cses_shiny_data.rda
# 2. cses_variable_labels.csv
# 3. cses_labs.rds
# 4. and fonts from /wwww/
### Data Out: N/A
# # -----------------------------------------------------------------------
options(shiny.useragg = TRUE) # speed it up

# # -----------------------------------------------------------------------
# Packages loading
# # -----------------------------------------------------------------------
library(lapop); library(bslib); library(htmltools); require(bsplus)
suppressPackageStartupMessages(library(dplyr))
library(tidyr); library(stringr); library(haven)
require(shiny); library(shinyWidgets); require(shinyjs); require(ggtext)
suppressPackageStartupMessages(library(Hmisc, exclude = c("src", "summarize", "units", "format.pval")))

lapop_fonts() # LAPOP GRAPH STYLE

# IMD CSES Data (only preselected variables)
# # -----------------------------------------------------------------------
# RDA FILE BEST COMPRESSION FOR RSHINY
load(file="./cses_shiny_data.rda");

# Labels data (for DP display)
vars_labels <- read.csv("./cses_variable_labels.csv", encoding = "latin1")

# Labs vector (for DP display outcomes versus secondary vars that include macro vars)
labs <- readRDS("./cses_labs.rds")
labs_sec <- readRDS("./cses_labs_sec.rds")
load(file="./world.rda")

# Dropping Demographics (OLD, ALLOW USERS TO USE BOTH RAW AND RECODE DEMOG VARS)
#drop_demoglabs <- c("IMD2001_2", "IMD2002", "IMD2003", "IMD2006", "IMD2007") # Demographics
#labs_sec <- labs[ !(unname(labs) %in% drop_demoglabs) ]

# # -----------------------------------------------------------------------
# Error handling function (so app does not break easily)
# # -----------------------------------------------------------------------

Error<-function(x){
  tryCatch(x,error=function(e) return(FALSE))
}

# CSES election-year vector for TS
waves_total = c("1996", "1997", "1998", "1999", "2000", "2001", "2002",
                "2003", "2004", "2005", "2006", "2007", "2008", "2009",
                "2010", "2011", "2012", "2013", "2014", "2015", "2016",
                "2017", "2018", "2019", "2020",  "2021")

# Escape stuff that ggtext/markdown treats specially
sanitize_for_ggtext <- function(x) {
  x <- as.character(x)
  # HTML specials
  x <- gsub("&", "&amp;", x, fixed = TRUE)
  x <- gsub("<", "&lt;",  x, fixed = TRUE)
  x <- gsub(">", "&gt;",  x, fixed = TRUE)
  # Markdown link/emphasis/backtick
  x <- gsub("\\[", "&#91;", x)
  x <- gsub("\\]", "&#93;", x)
  x <- gsub("\\(", "&#40;", x)
  x <- gsub("\\)", "&#41;", x)
  x <- gsub("\\*", "&#42;", x)
  x <- gsub("_",  "&#95;", x)
  x <- gsub("`",  "&#96;", x)
  x
}

# # -----------------------------------------------------------------------
# Helper function for TS
# # -----------------------------------------------------------------------
# (handle missing values at end or middle of series)

omit_na_edges <- function(df) {
  # Find which rows have NA values
  na_rows <- apply(df, 1, function(row) any(is.na(row)))

  # Find the first and last non-NA row
  first_non_na <- which(!na_rows)[1]
  last_non_na <- which(!na_rows)[length(which(!na_rows))]

  # Subset df to only include rows between the first and last non-NA rows
  df_clean <- df[first_non_na:last_non_na, ]

  return(df_clean)
}

# # -----------------------------------------------------------------------
# Custom weighted averages & CIs, much faster than survey_mean() etc
# # -----------------------------------------------------------------------
weighted.ttest.ci <- function(x, weights) {
  nx <- length(x)
  vx <- Hmisc::wtd.var(x, weights, normwt = TRUE, na.rm = TRUE) # Weighted variance
  mx <- weighted.mean(x, weights, na.rm = TRUE) # Weighted mean
  stderr <- sqrt(vx/nx)
  tstat <- mx/stderr ## not mx - mu
  cint <- qt(1 - 0.05/2, nx - 1)
  cint <- tstat + c(-cint, cint)
  confint = cint * stderr
  result = data.frame(prop = mx, lb = confint[1], ub = confint[2])
  return(result)
}

# # -----------------------------------------------------------------------
# Helper for missing country-year by outcome_var
# # -----------------------------------------------------------------------
get_missing_combinations <- function(data, outcome_var, wave_var,
                                     selected_waves, selected_countries) {
  # Convert wave values to string using haven labels
  data <- data %>%
    mutate(wave_str = as.character(haven::as_factor(.data[[wave_var]])))

  # Build the full country-wave grid
  all_combos <- expand.grid(
    pais_nam = selected_countries,
    wave = selected_waves,
    stringsAsFactors = FALSE
  )

  # Subset only relevant countries
  data <- data %>%
    filter(pais_nam %in% selected_countries)

  # Summarize: how many valid (non-NA and not 0) values exist per combo
  summary <- data %>%
    group_by(pais_nam, wave = wave_str) %>%
    summarise(
      n_valid = sum(!is.na(.data[[outcome_var]]) & .data[[outcome_var]] != 0),
      .groups = "drop"
    )

  # Merge and detect missing
  missing <- all_combos %>%
    left_join(summary, by = c("pais_nam", "wave")) %>%
    filter(is.na(n_valid) | n_valid == 0) %>%
    select(pais_nam, wave)

  return(missing)
}

# # -----------------------------------------------------------------------
# Helper function for mover plot (weighting and handling NAs)
# # -----------------------------------------------------------------------
process_data <- function(data, outcome_var, recode_range,
                         group_var, var_label, weight_var) {

  if (is.null(group_var)) {
    return(NULL)
  }

  processed_data <- data %>%
    drop_na(!!sym(outcome_var)) %>%
    mutate(outcome_rec = case_when(
      is.na(!!sym(outcome_var)) ~ NA_real_,
      !!sym(outcome_var) >= recode_range[1] & !!sym(outcome_var) <= recode_range[2] ~ 100,
      TRUE ~ 0
    )) %>%
    group_by(vallabel = haven::as_factor(haven::zap_missing(!!sym(group_var)))) %>%
    summarise_at(vars("outcome_rec"), list(~weighted.ttest.ci(., !!sym(weight_var)))) %>%
    unnest_wider(col = "outcome_rec") %>%
    mutate(
      varlabel = var_label,
      proplabel = paste0(round(prop), "%")
    ) %>%
    drop_na(.)

  return(processed_data)
}

# # -----------------------------------------------------------------------
# BOOTSTRAP THEME
# # -----------------------------------------------------------------------
cses_theme <- bs_theme(
  version = 5,
  bootswatch = "cosmo",
  bg = "#ffffff",
  fg = "#212529",
  primary = "#C4722A",
  secondary = "#C4722A",
  success = "#28a745",
  info = "#0066cc",
  warning = "#dc3545",
  danger = "#dc3545",
  #base_font = font_google("Open Sans"),
  #heading_font = font_google("Roboto Slab"),
  #code_font = font_google("Fira Mono"),
  #font_scale = 1
)

# # -----------------------------------------------------------------------
# HOVER POP-UP FOR LEFTSIDE MENU
# # -----------------------------------------------------------------------
info_badge <- function(text, title, content) {
  bsplus::bs_embed_popover(
    tags$span(text, tags$span(icon("info-circle"), class = "me-1",  style = "color:#C4722A;")),
    title = title,
    content = content,
    placement = "right",
    trigger = "click",
    container = "body"
  )
}

# # -----------------------------------------------------------------------
# N-SIZE FUNCTION TO PULL COUNTRY-YEAR COMBOS (CHATGPT)
# # -----------------------------------------------------------------------
get_sample_counts <- function(
    data, outcome_var,
    wave_var = "wave", country_var = "pais_nam",
    selected_waves = NULL, selected_countries = NULL,
    complete_grid = FALSE
) {
  df <- data
  if (!is.null(selected_waves))     df <- dplyr::filter(df, .data[[wave_var]] %in% selected_waves)
  if (!is.null(selected_countries)) df <- dplyr::filter(df, .data[[country_var]] %in% selected_countries)
  df <- dplyr::filter(df, !is.na(.data[[outcome_var]]))

  per_wave <- df |>
    dplyr::count(wave = .data[[wave_var]], name = "n") |>
    dplyr::arrange(wave)

  per_country <- df |>
    dplyr::count(pais = .data[[country_var]], name = "n") |>
    dplyr::arrange(pais)

  per_country_wave <- df |>
    dplyr::count(pais = .data[[country_var]], wave = .data[[wave_var]], name = "n") |>
    dplyr::arrange(pais, wave)

  if (complete_grid) {
    all_waves <- if (!is.null(selected_waves)) selected_waves else sort(unique(data[[wave_var]]))
    all_countries <- if (!is.null(selected_countries)) selected_countries else sort(unique(data[[country_var]]))

    per_country_wave <- per_country_wave |>
      tidyr::complete(pais = all_countries, wave = all_waves, fill = list(n = 0)) |>
      dplyr::arrange(pais, wave)

    per_country <- per_country_wave |>
      dplyr::group_by(pais) |>
      dplyr::summarise(n = sum(n), .groups = "drop") |>
      dplyr::arrange(pais)

    per_wave <- per_country_wave |>
      dplyr::group_by(wave) |>
      dplyr::summarise(n = sum(n), .groups = "drop") |>
      dplyr::arrange(wave)
  }

  list(
    overall = nrow(df),
    per_wave = per_wave,
    per_country = per_country,
    per_country_wave = per_country_wave
  )
}

# # -----------------------------------------------------------------------
# # -----------------------------------------------------------------------
# # -----------------------------------------------------------------------

# # -----------------------------------------------------------------------
# Creating User Interface UI!
# # -----------------------------------------------------------------------
ui <- fluidPage(

  useShinyjs(),

  theme = cses_theme,
  tags$h2("CSES Data Playground",
          style = "color: #C4722A; font-weight: bold; font-size: 36px;"),

  sidebarLayout(
    # ----- Sidebar panel for inputs
    sidebarPanel(width = 3,
      selectInput("variable", "Outcome",
                  labs[order(names(labs))],
                  selected = "IMD3010"),
      # Default picks most recent module
      pickerInput(inputId = "module",
                  label = tagList(info_badge("Module",
                          HTML("Please select which CSES Modules to be available in the analysis. Then, select which countries and years below."),
                          "Module")),
                  choices = sort(levels(as_factor(cses_shiny_data$IMD1008_MOD)[!is.na(cses_shiny_data$IMD1008_MOD)])),
                  selected = c("MODULE 5"),
                  options = list(`actions-box` = TRUE),
                  multiple = TRUE),

      # ----- COUNTRY
      pickerInput(inputId = "pais",
                  label = "Countries",
                    #tagList(info_badge("Countries",
                    #HTML("Please select which countries to be included in the analysis."),
                    #"Countries")),
                  choices = sort(levels(as_factor(cses_shiny_data$pais)[!is.na(cses_shiny_data$pais)])),
                  options = list(`actions-box` = TRUE),
                  multiple = TRUE),

      # ----- WAVE
      pickerInput(inputId = "wave",
                  label = "Years",
                  #tagList(info_badge("Years",
                  #                           HTML("Please select which years to be included in the analysis."),
                  #                           "Years")),
                  choices = c("1996" = "1996", "1997" = "1997", "1998" = "1998",
                              "1999" = "1999", "2000" = "2000", "2001" = "2001",
                              "2002" = "2002", "2003" = "2003", "2004" = "2004",
                              "2005" = "2005", "2006" = "2006", "2007" = "2007",
                              "2008" = "2008", "2009" = "2009", "2010" = "2010",
                              "2011" = "2011", "2012" = "2012", "2013" = "2013",
                              "2014" = "2014", "2015" = "2015", "2016" = "2016",
                              "2017" = "2017", "2018" = "2018", "2019" = "2019",
                              "2020" = "2020", "2021" = "2021"),
                  options = list(`actions-box` = TRUE),
                  multiple = TRUE),

      # ----- WEIGHT selection radio buttons
      bsplus::use_bs_popover(),
      radioButtons(
        inputId = "weight_type",
        label = tagList(info_badge("Weights",
                        HTML("Further information on weights is available in <b>Part 6</b> of CSES Module 4."),
                        "Weights")),
        # For a link, add:
        # HTML('Further information on weights is available in <b>Part 6</b> of CSES Module 4. <br><a href=\"#\" target=\"_blank\">Open doc</a>')
        choiceValues = c("no_weight", "weight_demographic", "weight_sample"),
        choiceNames  = list(
          info_badge("Unweighted", "No weights applied. Raw proportions/percentages.",
                     "Unweighted"),
          info_badge("Demographic weight", "Post-stratification targets.",
                     "Demographic weight"),
          info_badge("Sample weight", "Design/selection probability weights.",
                     "Sample weight")
        ),
        selected = "no_weight"),

      # This fixes a formatting issue with checkboxGroupInput() below
      tags$head(
        tags$style(
          HTML("

          .checkbox-inline {

                    margin-left: 0px;

                    margin-right: 10px;

          }

         .checkbox-inline+.checkbox-inline {

                    margin-left: 0px;

                    margin-right: 10px;

         }

    .shiny-notification {

      width: 615px !important; /* max width */

      max-height: 140px; /* max height */

      word-wrap: break-word;

      white-space: normal;

      overflow-y: auto; /* scrollbar */

      right: 330px !important; /* shift away from right edge */

      box-sizing: border-box;

      font-size: 14px;

    }"))),

      # This triggers the "Generate" button
      tags$script(HTML("

      Shiny.addCustomMessageHandler('clickGenerateButton', function(message) {

    $('#go').click();

  });

")),
      # This makes the slider input to allow only integers for CSES years
      tags$style(type = "text/css", ".irs-grid-pol.small {height: 0px;}"),

# Make popovers white + wire TRUE hover with JavaScript
      tags$style(HTML("

  .popover {

    --bs-popover-bg: #ffffff;

    --bs-popover-border-color: #dddddd;

    --bs-popover-header-bg: #ffffff;

    --bs-popover-header-color: #212529;

    --bs-popover-body-color: #212529;

    border-color: #dddddd;

  }

  .popover .popover-header,

  .popover .popover-body {

    background-color: #ffffff;

    color: #212529;

  }

")),
      tags$script(HTML("

(function() {

  function upgradeDataAttr(el){

  // Force manual disable

    if (el.getAttribute('data-toggle') === 'popover') {

      el.setAttribute('data-bs-toggle','popover');

      el.removeAttribute('data-toggle');

    }

  }



  function getPopover(el){

    // Force manual trigger so we fully control hover behavior

    return bootstrap.Popover.getOrCreateInstance(el, {

      container: 'body',

      trigger: 'manual',

      html: true, sanitize: false

    });

  }



  function addHoverBehavior(el){

    var timer = null;

    var inst  = getPopover(el);



    function startHide(delay){

      if (timer) clearTimeout(timer);

      timer = setTimeout(function(){

        inst.hide();

      }, delay);

    }

    function cancelHide(){

      if (timer) { clearTimeout(timer); timer = null; }

    }



    // Show on hover

    el.addEventListener('mouseenter', function(){

      cancelHide();

      inst.show();



      // Auto-dismiss after 10s (unless user is hovering the popover)

      startHide(10000);

    });



    // Hide shortly after leaving the icon (unless pointer is on the popover)

    el.addEventListener('mouseleave', function(){

      // small delay to allow moving into the popover

      setTimeout(function(){

        var pop = document.getElementById(el.getAttribute('aria-describedby'));

        if (!pop || !pop.matches(':hover')) inst.hide();

      }, 150);

    });



    // Keep open while hovering the popover; hide when leaving it

    el.addEventListener('shown.bs.popover', function(){

      var pop = document.getElementById(el.getAttribute('aria-describedby'));

      if (!pop) return;

      pop.addEventListener('mouseenter', cancelHide);

      pop.addEventListener('mouseleave', function(){

        startHide(150);  // quick close after leaving the box

      });

    });



    // Prevent click toggling from fighting our hover logic

    el.addEventListener('click', function(e){ e.preventDefault(); });

  }



  document.addEventListener('DOMContentLoaded', function(){

    document.querySelectorAll('[data-bs-toggle=\"popover\"], [data-toggle=\"popover\"]').forEach(function(el){

      upgradeDataAttr(el);

      getPopover(el);       // ensure BS5 instance exists

      addHoverBehavior(el); // wire hover behavior + auto-dismiss

    });

  });

})();

")),
      # Show recode slider only for TS, CC, and mover plots (not for histogram)
      conditionalPanel(
        'input.tabs == "Time Series" |

        input.tabs == "Cross Country" |

        input.tabs == "World Map" |

        input.tabs == "Breakdown"',

        uiOutput("sliderUI"),
        # Mean Value toggle
       # checkboxInput("use_mean", "Mean value", FALSE),
      ),

      # Add additional breakdown variable in mover plot
      conditionalPanel(
        'input.tabs == "Breakdown"',
        selectInput("variable_sec",
                    label = tagList(
          info_badge("Subgroup for analysis",
                    HTML("Optionally split the Breakdown plot by another subgroup from the dataset.

                 Select <b>None</b> to disable."), "Secondary Variable")),
                    c("None" = "None",
                      labs_sec[order(names(labs_sec))])),
        checkboxGroupInput("demog", "Demographic Variables",
                           c("Gender" = "gendermc",
                             "Age" = "age",
                             "Income" = "wealth",
                             "Education" = "edre",
                             "Urban/Rural" = "ur"),
                           selected = c("gendermc", "age", "edre"),
                           inline = TRUE)),
      # Include button in UI (disabled)
      #actionButton("go", "Generate")
      tags$div(
        style = "display: none;",
        actionButton("go", "Generate"))),

    # Main panel for displaying outputs ----
    # # -----------------------------------------------------------------------
    mainPanel(
      # Output: Formatted text for caption ----
      h3(textOutput("caption")),
      h5(textOutput("wording")),
      h5(textOutput("response")),
      tabsetPanel(id = "tabs",
                  tabPanel("Histogram", plotOutput("hist")),
                  tabPanel("Time Series", plotOutput("ts")),
                  tabPanel("Cross Country", plotOutput("cc")),
                  tabPanel("Breakdown", plotOutput("mover")),
                  tabPanel("World Map", plotOutput("map"))),

      br(),
      fluidRow(column(12,
                      tags$div(style = "margin-top:-15px"),
                      downloadButton(outputId = "downloadPlot", label = "Download Figure"),
                      downloadButton(outputId = "downloadTable", label = "Download Table"),
                      tags$div(style = "height:10px"),
                      uiOutput("ns_card"),
                      #uiOutput("missing_warning_card"),
        )
      )
    )
  )
)

# # -----------------------------------------------------------------------
# # -----------------------------------------------------------------------
# # -----------------------------------------------------------------------

# # -----------------------------------------------------------------------
# Define SERVER logic
# # -----------------------------------------------------------------------
# The server function will be called when each client (browser) loads the app.
server <- function(input, output, session) {
  observe({
    req(input$variable)
    if (!input$variable %in% names(cses_shiny_data)) {
      showNotification("Selected variable not found in data!", type = "error")
    }
    if (!input$weight_type %in% names(cses_shiny_data)) {
      showNotification("Selected weight column not found!", type = "error")
    }
  })

  # Triggers "go" between server and ui to generate default plots
  observe({
    if (!is.null(input$module) && !is.null(input$pais) && !is.null(input$wave)) {
      isolate({
        session$sendCustomMessage("clickGenerateButton", list())
      })
    }
  })

  # Check the number of selected variables for breakdown
   observeEvent(input$demog, {
    if (length(input$demog) > 3) {
      # Show a warning message
      showNotification(HTML("You should only select a maximum of 3 demographic variables to plot."), type = "warning")
    }
  })

  # MAKE IT REACTIVE
  # # -----------------------------------------------------------------------
  formulaText <- reactive({
    paste(input$variable)
  })

  outcome <- reactive({
    input$variable
  })

  wave <- reactive({
    input$wave
  })

  outcome_code <- reactive({
    vars_labels$column_name[which(vars_labels$column_name == paste(outcome()))]
  })

  outcome_lab <- reactive({
    vars_labels$question_short_en[which(vars_labels$column_name == paste(outcome()))]
  })

  variable_sec <- reactive({
    input$variable_sec
  })

  variable_sec_lab <- reactive({
    vars_labels$question_short_en[which(vars_labels$column_name == paste(variable_sec()))]
  })

  sliderParams <- reactiveValues(valuex = c(1, 1))

  # Reactive: Filter dataset based on selected module(s)
  # # -----------------------------------------------------------------------
  filtered_data <- reactive({
    req(input$module)
    cses_shiny_data %>%
      dplyr::filter(IMD1008_MOD %in% input$module)
  })

# OLD CODE THAT WOULD FORCE PRESELECTION, BUT IT BREAKS THE APP WITH FULL DATASET
# Observe changes in module input to update wave and pais
  observeEvent(filtered_data(), {
    data <- filtered_data()

    wave_choices <- sort(unique(data$wave))
    pais_choices <- sort(unique(data$pais))

    updatePickerInput(
      session = session,
      inputId = "wave",
      choices = wave_choices,
      selected = wave_choices  # you can leave this empty if no preselection
    )
#
#    updatePickerInput(
#      session = session,
#      inputId = "pais",
#      choices = pais_choices,
#      selected = pais_choices
#    )
})

  all_waves  <- sort(unique(cses_shiny_data$wave))
  all_paises <- sort(unique(cses_shiny_data$pais))

  observeEvent(input$module, {
    req(input$module)

    # Filter for the selected module
    valid <- dplyr::filter(cses_shiny_data, IMD1008_MOD %in% input$module)
    valid_waves  <- sort(unique(valid$wave))
    valid_paises <- sort(unique(valid$pais))

    wave_disabled <- !(all_waves %in% valid_waves)
    pais_disabled <- !(all_paises %in% valid_paises)

    # 🔹 Automatically select *all valid waves* when a module is chosen
    shinyWidgets::updatePickerInput(
      session, "wave",
      choices = all_waves,
      selected = valid_waves,  # <-- changed line
      choicesOpt = list(
        disabled = wave_disabled,
        style    = ifelse(wave_disabled, "color:#999;", "")
      )
    )

    # 🔹 Automatically select *all valid countries* too (optional)
    shinyWidgets::updatePickerInput(
      session, "pais",
      choices = all_paises,
      selected = valid_paises,  # <-- changed line
      choicesOpt = list(
        disabled = pais_disabled,
        style    = ifelse(pais_disabled, "color:#999;", "")
      )
    )
  })


# Set default recode slider values:
# # -----------------------------------------------------------------------
# 2-point: 1-1
# 3-point: 3-3
# 4-point: 1-2
# 5-point: 4-5
# 6-point: 3-3
# 7-point: 5-7
# 10-point: 8-10
# ALL OTHER: MEAN

# UPDATE SLIDER DEFAULTS AND MEAN BEHAVIOR
# -----------------------------------------------------------------------
observeEvent({
  list(input$variable, input$use_mean)
}, {
  # compute numeric vector safely
  xvals <- suppressWarnings(as.numeric(cses_shiny_data[[formulaText()]]))
  maxval <- max(xvals, na.rm = TRUE)

  # --- DEFAULT RECODE RANGES ---
  if (maxval == 1) {
    sliderParams$valuex <- c(1, 1)
  } else if (maxval == 2) {
    sliderParams$valuex <- c(1, 1)
  } else if (maxval == 3) {
    sliderParams$valuex <- c(3, 3)
  } else if (maxval == 4) {
    sliderParams$valuex <- c(1, 2)
  } else if (maxval == 5) {
    sliderParams$valuex <- c(4, 5)
  } else if (maxval == 6) {
    sliderParams$valuex <- c(3, 3)
  } else if (maxval == 7) {
    sliderParams$valuex <- c(5, 7)
  } else if (maxval == 10) {
    sliderParams$valuex <- c(8, 10)
  } else {
    mean_val <- mean(xvals, na.rm = TRUE)
    sliderParams$valuex <- c(mean_val, mean_val)
  }

  # --- IF USER SELECTED "USE MEAN VALUE" ---
  if (isTRUE(input$use_mean)) {
    mean_val <- mean(xvals, na.rm = TRUE)
    sliderParams$valuex <- c(mean_val, mean_val)
  }

  # force slider update
  updateSliderInput(
    session,
    inputId = "recode",
    value = sliderParams$valuex
  )
})

# RECODE SLIDER
# # -----------------------------------------------------------------------
output$sliderUI <- renderUI({
  sliderInput(
    inputId = "recode",
    label = tagList(
      info_badge(
        "Which values do you want to graph?",
        HTML("Please select which outcome values to be displayed."),
        "Which values do you want to graph?"
      )
    ),
    min = min(as.numeric(cses_shiny_data[[formulaText()]]), na.rm = TRUE),
    max = max(as.numeric(cses_shiny_data[[formulaText()]]), na.rm = TRUE),
    value = sliderParams$valuex,
    step = 1
  )
})


# Filtering data based on user's selection (dff)
dff <- eventReactive(input$go, ignoreNULL = FALSE, {
  cses_shiny_data %>%
    dplyr::filter(as_factor(wave) %in% input$wave) %>% # year
    dplyr::filter(pais_nam %in% input$pais) # country
})

# Rendering var caption based on user's var selection
cap <- renderText({
  vars_labels$question_short_en[which(vars_labels$column_name == formulaText())]
})
output$caption <- renderText({
  cap()
})

# Rendering variable code + wording based on user's var selection
word <- renderText({
  paste0(toupper(vars_labels$column_name[which(vars_labels$column_name == formulaText())]), ". ",
         vars_labels$question_en[which(vars_labels$column_name == formulaText())])
})
output$wording <- renderText({
  word()
})

# Rendering ROs based on user's var selection
resp <- renderText({
  vars_labels$responses_en_rec[which(vars_labels$column_name == formulaText())]
})
output$response <- renderText({
  resp()
})

# Rendering variable_sec ROs
resp_sec <- renderText({
  vars_labels$responses_en_rec[which(vars_labels$column_name == input$variable_sec)]
})
output$response_sec <- renderText({
  resp_sec()
})

# Rendering User selected recode value(s)
slider_values <- renderText({
  if(input$recode[1] == input$recode[2]) {
    paste0("(value: ", unique(input$recode), ")")
  } else {
    paste0("(range: ", paste(input$recode, collapse = " to "), ")")
  }
})
output$selected_values <- renderText({
  slider_values()
})


# Toggle recode slider
# # -----------------------------------------------------------------------
observe({
  if (isTRUE(input$use_mean)) {
    shinyjs::disable("recode")
  } else {
    shinyjs::enable("recode")
  }
})

# # -----------------------------------------------------------------------
# N-SIZE CARD
# # -----------------------------------------------------------------------
output$ns_card <- renderUI({
    req(dff(), outcome(), input$wave, input$pais)

selected_waves <- as.character(input$wave)
selected_countries <- as.character(input$pais)

ns <- get_sample_counts(
      data = dff(),
      outcome_var = outcome(),
      wave_var = "wave",
      country_var = "pais_nam",   # adjust if your helper uses a different input col
      selected_waves = selected_waves,
      selected_countries = selected_countries
    )

    # If absolutely no non-missing data, show a gentle note
    if (is.null(ns$overall) || ns$overall == 0) {
      return(tags$div(
        style = "border:2px solid #17a2b8; border-radius:8px; padding:14px; background:#e9f7ff; margin-bottom:20px;",
        HTML(paste0("ℹ️ <b>Ns</b> for <b>", outcome(), "</b>: No non-missing observations in the current selection."))
      ))
    }

    # Expect columns: ns$per_wave (wave, n) and ns$per_country_wave (pais, wave, n)
    pCW <- ns$per_country_wave
    # If your helper names the country column differently, change "pais" below

    # Control whether to show zeros
    show_zeros <- FALSE

    # Order waves nicely
    waves <- unique(pCW$wave)

    # If waves are numeric-like but char, coerce to numeric for sorting (silently)
    suppressWarnings({
      wave_num <- suppressWarnings(as.numeric(as.character(waves)))
      if (all(!is.na(wave_num))) waves <- waves[order(wave_num)] else waves <- sort(waves)
    })

    # Create a quick lookup for total N per wave
    per_wave_tbl <- ns$per_wave |>
      dplyr::mutate(wave_chr = as.character(wave)) |>
      dplyr::select(wave_chr, n)

    # Build one <details> block per wave
    blocks <- lapply(seq_along(waves), function(i) {
      w <- waves[i]
      w_chr <- as.character(w)

      wt <- per_wave_tbl$n[match(w_chr, per_wave_tbl$wave_chr)]
      wt <- ifelse(is.na(wt), 0, wt)

      rows <- pCW |>
        dplyr::filter(as.character(wave) == w_chr)

      if (!show_zeros) rows <- dplyr::filter(rows, n > 0)

      rows <- dplyr::arrange(rows, dplyr::desc(n), .by_group = FALSE)

      items <- lapply(seq_len(nrow(rows)), function(j) {
        n_j <- format(rows$n[j], big.mark = ",")
        is_zero <- isTRUE(rows$n[j] == 0)
        li_style <- if (is_zero) "color:#6c757d;" else NULL
        # country column is "pais" as returned by the helper
        tags$li(
          tags$span(HTML(paste0("<b>", rows$pais[j], "</b>: N=", n_j))),
          style = li_style
        )
      })

      tags$details(
        open = (i == 1),  # first year open by default
        class = "ns-year",
        tags$summary(
          HTML(paste0("<b>", w_chr, "</b> — Total N=", format(wt, big.mark=",")))
        ),
        tags$ul(items)
      )
    })

    tags$div(
      style = "border:2px solid #17a2b8;

      border-radius:8px;

      padding:14px;

      background:#e9f7ff;

      margin-bottom:20px;

      max-height:180px;

      overflow-y:auto;",
      # Title + grand total
      tags$div(
        HTML(paste0(
          "📊 <b>Sample sizes</b> (non-missing <b>", outcome(), "</b>)<br>",
          "<b>Total across selection:</b> ", format(ns$overall, big.mark = ",")
        )),
        style = "margin-bottom:6px;"
      ),
      tags$hr(style="margin:8px 0;"),
      # Small CSS polish for the dropdowns
      tags$style(HTML("

      details.ns-year { margin-bottom: 8px; }

      details > summary { cursor: pointer; list-style: none; }

      details > summary::-webkit-details-marker { display: none; }

    ")),
      blocks
    )
  })

# -----------------------------------------------------------------------
# SOURCE INFO WITH ACTUAL DATA AVAILABILITY (not just user selections)
# -----------------------------------------------------------------------
source_info_both <- reactive({
  req(dff(), outcome(), input$wave, input$pais, input$module)

  # Reuse your helper to get Ns
  ns <- get_sample_counts(
    data = dff(),
    outcome_var = outcome(),
    wave_var = "wave",
    country_var = "pais_nam",
    selected_waves = input$wave,
    selected_countries = input$pais
  )

  # Extract actual combinations with nonzero N
  valid_combos <- ns$per_country_wave %>%
    dplyr::filter(n > 0)

  # Actual waves and countries that have data
  valid_waves <- sort(unique(valid_combos$wave))
  valid_countries <- sort(unique(valid_combos$pais))
  selected_module = input$module

  # Get abbreviations for these countries (match order)
  pais_abbr <- cses_shiny_data %>%
    dplyr::filter(pais_nam %in% valid_countries) %>%
    distinct(pais_nam, pais_lab) %>%
    arrange(match(pais_nam, valid_countries)) %>%
    pull(pais_lab)

  paste0(
    "Source: CSES Data Playground\n\n",
    str_wrap(paste0("CSES ", selected_module,
      " - Years: ", paste(valid_waves, collapse = ", "),
      ". Countries: ", paste(pais_abbr, collapse = ", ")
    ), 130),
    "\n\n",
    str_wrap(paste0(word(), " ", resp()), 130)
  )
})

# -----------------------------------------------------------------------
source_info_pais <- reactive({
  req(dff(), outcome(), input$wave, input$pais)

  ns <- get_sample_counts(
    data = dff(),
    outcome_var = outcome(),
    wave_var = "wave",
    country_var = "pais_nam",
    selected_waves = input$wave,
    selected_countries = input$pais
  )

  valid_combos <- ns$per_country_wave %>%
    dplyr::filter(n > 0)

  valid_countries <- sort(unique(valid_combos$pais))

  pais_abbr <- cses_shiny_data %>%
    dplyr::filter(pais_nam %in% valid_countries) %>%
    distinct(pais_nam, pais_lab) %>%
    arrange(match(pais_nam, valid_countries)) %>%
    pull(pais_lab)

  paste0(
    "Source: CSES Data Playground\n",
    "Countries: ", str_wrap(paste(pais_abbr, collapse = ", "), 130),
    "\n\n",
    str_wrap(paste0(word(), " ", resp()), 130)
  )
})

# -----------------------------------------------------------------------
source_info_wave <- reactive({
  req(dff(), outcome(), input$wave, input$pais, input$module)

  ns <- get_sample_counts(
    data = dff(),
    outcome_var = outcome(),
    wave_var = "wave",
    country_var = "pais_nam",
    selected_waves = input$wave,
    selected_countries = input$pais
  )

  valid_combos <- ns$per_country_wave %>%
    dplyr::filter(n > 0)
  valid_waves <- sort(unique(valid_combos$wave))
  selected_module = input$module

  paste0(
    "Source: CSES Data Playground\n", "CSES ", selected_module,
    " - Years: ", str_wrap(paste(valid_waves, collapse = ", "), 130),
    "\n\n",
    str_wrap(paste0(word(), " ", resp()), 130)
  )
})
# # -----------------------------------------------------------------------
# PLOTS
# # -----------------------------------------------------------------------

# Histogram
# # -----------------------------------------------------------------------
# must break into data event, graph event, and renderPlot to get download to work
  histd <- reactive({
    req(dff(), input$variable, input$weight_type)

    if (!input$variable %in% names(dff()) ||
        !input$weight_type %in% names(dff())) {
      return(NULL)
    }

    tryCatch({
      dff() %>%
        drop_na(!!sym(input$variable), !!sym(input$weight_type)) %>%
        group_by(cat = haven::as_factor(!!sym(input$variable))) %>%
        summarise(w = sum(!!sym(input$weight_type), na.rm = TRUE)) %>%
        mutate(
          prop = w / sum(w) * 100,
          proplabel = paste0(round(prop), "%"),
          cat = str_wrap(as.character(cat), width = 25)
        )
    }, error = function(e) {
      NULL
    })
  })

  histg <- reactive({lapop_hist(histd(),
                        ymax = ifelse(any(histd()$prop > 90), 110, 100),
                        source_info = "Source: CSES Data Playground")})

  output$hist <- renderPlot({
    req(dff(), nrow(dff()) > 0, input$variable, input$variable %in% names(dff()))
    return(histg())
  })

# Time-series
# # -----------------------------------------------------------------------
  tsd <- reactive({
    dta_ts <- Error(
      dff() %>%
        drop_na(!!sym(outcome()), !!sym(input$weight_type)) %>%
        mutate(outcome_rec = case_when(
          !!sym(outcome()) >= input$recode[1] &
            !!sym(outcome()) <= input$recode[2] ~ 100,
          TRUE ~ 0
        )) %>%
        group_by(wave = as.character(as_factor(wave))) %>%
        summarise_at(
          vars("outcome_rec"),
          list(~weighted.ttest.ci(., !!sym(input$weight_type)))
        ) %>%
        unnest_wider(col = "outcome_rec") %>%
        mutate(proplabel = paste0(round(prop), "%")) %>%
        dplyr::filter(prop != 0)
    )

    validate(
      need(dta_ts, "Error: no data available. Please verify that this question was asked in this country/year combination.")
    )

    dta_ts <- merge(dta_ts,
                    data.frame(wave = as.character(waves_total), empty = 1),
                    by = "wave", all.y = TRUE) %>%
      dplyr::filter(!is.na(prop)) # TO EXCLUDE YEARS NOT IN THE SELECTION
                                  # THEN YEARS ARE NOT SEQUENTIAL

    return(omit_na_edges(dta_ts))
  })

  tsg <- reactive({lapop_ts(tsd(),
                   ymax = ifelse(any(tsd()$prop > 85, na.rm = TRUE), 110, 100),
                   #label_vjust = -1.5,
                   label_vjust = ifelse(any(tsd()$prop > 80, na.rm = TRUE), -1.1, -1.5),
                   source_info = "Source: CSES Data Playground",
                   subtitle = "% in selected category",
                   ci_type = "errorbar")
  })

  output$ts <- renderPlot({
    return(tsg())
  })

# Cross Country
# # -----------------------------------------------------------------------
# define macro (aggregate-level) variables
continuous_vars <- c("IMD3001_TS", "IMD5054_2", "IMD5057_1", "IMD5035",
                     "IMD5056_2", "IMD5055_1", "IMD5053_1", "IMD5052_2")

  ccd <- reactive({
    var_sel <- outcome()
    rec_min <- input$recode[1]
    rec_max <- input$recode[2]

    # CASE 1: Continuous macro-level variable (mean = TRUE)
    if (var_sel %in% continuous_vars) {
      curr_outcome <- sym(var_sel)

      dta_cc <- dff() %>%
        # Apply recode range first
        mutate(
          tmp_val = as.numeric(!!curr_outcome),
          tmp_val = ifelse(tmp_val >= rec_min & tmp_val <= rec_max, tmp_val, NA_real_)
        ) %>%
        group_by(vallabel = pais_lab) %>%
        summarise(
          prop = mean(tmp_val, na.rm = TRUE)
        ) %>%
        ungroup() %>%
        mutate(
          lb = NA_real_,
          ub = NA_real_,
          proplabel = ifelse(is.na(prop), "", sprintf("%.2f", prop))
        ) %>%
        filter(!is.na(prop))

      # CASE 2: Regular individual-level variable (weighted proportion)
    } else {

      dta_cc <- dff() %>%
        drop_na(!!sym(var_sel), !!sym(input$weight_type)) %>%
        mutate(outcome_rec = case_when(
          !!sym(var_sel) >= rec_min & !!sym(var_sel) <= rec_max ~ 100,
          TRUE ~ 0
        )) %>%
        group_by(vallabel = pais_lab) %>%
        summarise_at(
          vars("outcome_rec"),
          list(~weighted.ttest.ci(., !!sym(input$weight_type)))
        ) %>%
        unnest_wider(col = "outcome_rec") %>%
        filter(prop != 0) %>%
        mutate(proplabel = paste0(round(prop), "%"))
    }

    validate(
      need(nrow(dta_cc) > 0,
           "Error: no data available. Please verify that this question was asked in this country/year combination.")
    )

    return(dta_cc)
  })

  ccg <- reactive({
    lapop_cc(
      ccd(),
      sort = "hi-lo",
      subtitle = ifelse(outcome() %in% continuous_vars,
                        "Countries (within selected range)",
                        "% in selected category"),
      ymax = ifelse(outcome() %in% continuous_vars, 6,
                    ifelse(any(ccd()$prop > 90, na.rm = TRUE), 110, 100)),
      source_info = "Source: CSES Data Playground"
    )
  })

  output$cc <- renderPlot({
    ccg()
  })

# World Map
# # -----------------------------------------------------------------------
  mapd <- reactive({

    var_sel <- outcome()
    rec_min <- input$recode[1]
    rec_max <- input$recode[2]

    continuous_vars <- c("IMD3001_TS", "IMD5054_2", "IMD5057_1", "IMD5035",
                         "IMD5056_2", "IMD5055_1", "IMD5053_1", "IMD5052_2")

    req(input$module)

    # --- NEW: allow only one module at a time ---
    validate(
      need(
        length(input$module) == 1,
        "Please select only ONE module to display a map."
      )
    )

    # CASE 1: Continuous macro variable (mean values)
    if (var_sel %in% continuous_vars) {

      dta_map <- dff() %>%
        mutate(
          tmp_val = as.numeric(.data[[var_sel]]),
          tmp_val = ifelse(tmp_val >= rec_min & tmp_val <= rec_max, tmp_val, NA_real_)
        ) %>%
        group_by(pais_lab = pais_lab) %>%       # IMPORTANT: must exist in your dataset
        summarise(
          value = mean(tmp_val, na.rm = TRUE),
          .groups = "drop"
        ) %>%
        filter(!is.na(value))

    } else {

      # CASE 2: Categorical / proportion variables
      dta_map <- dff() %>%
        drop_na(.data[[var_sel]], .data[[input$weight_type]]) %>%
        mutate(outcome_rec = case_when(
          .data[[var_sel]] >= rec_min & .data[[var_sel]] <= rec_max ~ 100,
          TRUE ~ 0
        )) %>%
        group_by(pais_lab = pais_lab) %>%
        summarise_at(
          vars("outcome_rec"),
          list(~weighted.ttest.ci(., .data[[input$weight_type]]))
        ) %>%
        unnest_wider(col = "outcome_rec") %>%
        filter(prop > 0) %>%
        rename(value = prop)
    }

    validate(
      need(nrow(dta_map) > 0,
           "Error: no map data available for this country/year/variable selection.")
    )

    return(dta_map)
  })

  mapg <- reactive({
    lapop_map(
      mapd(), survey = "CSES",
      source_info = "\nSource: CSES Data Playground"
    )
  })

  output$map <- renderPlot({
    mapg()
  })

# Breakdown
# # -----------------------------------------------------------------------
# Use function for each demographic breakdown variable

  secdf <- eventReactive(input$go, ignoreNULL = FALSE, {
    if (input$variable_sec == "None") {
      NULL
    } else if (variable_sec() == outcome()) {
      showNotification(HTML("You cannot break the outcome variable by itself."), type = "error")
      NULL
    } else {

      process_data(
        data = dff(),
        outcome_var = outcome(),
        recode_range = input$recode,
        group_var = input$variable_sec,
        weight_var = input$weight_type,
        var_label = stringr::str_wrap(variable_sec_lab(), width = 25)
      )
    }
  })

  genderdf <- eventReactive(input$go, ignoreNULL = FALSE, {
    if ("gendermc" %in% input$demog) {
      process_data(
        data = dff(),
        outcome_var = outcome(),
        recode_range = input$recode,
        weight_var = input$weight_type,
        group_var = "gendermc",
        var_label = "Gender"
      )
    } else {
      NULL
    }
  })

  wealthdf <- eventReactive(input$go, ignoreNULL = FALSE, {
    if ("wealth" %in% input$demog) {
      process_data(
        data = dff(),
        outcome_var = outcome(),
        recode_range = input$recode,
        weight_var = input$weight_type,
        group_var = "wealthf",
        var_label = "Wealth"
      )
    } else {
      NULL
    }
  })

  eddf <- eventReactive(input$go, ignoreNULL = FALSE, {
    if ("edre" %in% input$demog) {
      process_data(
        data = dff(),
        outcome_var = outcome(),
        recode_range = input$recode,
        weight_var = input$weight_type,
        group_var = "edrerf",
        var_label = "Education"
      )
    } else {
      NULL
    }
  })

  agedf <- eventReactive(input$go, ignoreNULL = FALSE, {
    if ("age" %in% input$demog) {
      process_data(
        data = dff(),
        outcome_var = outcome(),
        recode_range = input$recode,
        weight_var = input$weight_type,
        group_var = "age",
        var_label = "Age"
      )
    } else {
      NULL
    }
  })

  urdf <- eventReactive(input$go, ignoreNULL = FALSE, {
    if ("ur" %in% input$demog) {
      process_data(
        data = dff(),
        outcome_var = outcome(),
        recode_range = input$recode,
        weight_var = input$weight_type,
        group_var = "ur",
        var_label = "Place of\nResidence"
      )
    } else {
      NULL
    }
  })

  # Combine demographic data frames into one df
  moverd <- reactive({
    req(dff(), input$recode, input$weight_type)

    dta_mover <- Error(rbind(
      if (input$variable_sec != "None" && input$variable_sec != outcome()) {
        process_data(
          data = dff(),
          outcome_var = outcome(),
          recode_range = input$recode,
          group_var = input$variable_sec,
          weight_var = input$weight_type,
          var_label = str_wrap(variable_sec_lab(), width = 25)
        )
      },
      if ("gendermc" %in% input$demog) {
        process_data(dff(), outcome(), input$recode, "gendermc", "Gender",
                     input$weight_type)
      },
      if ("age" %in% input$demog) {
        process_data(dff(), outcome(), input$recode, "age", "Age",
                     input$weight_type)
      },
      if ("wealth" %in% input$demog) {
        process_data(dff(), outcome(), input$recode, "wealthf", "Wealth",
                     input$weight_type)
      },
      if ("edre" %in% input$demog) {
        process_data(dff(), outcome(), input$recode, "edrerf", "Education",
                     input$weight_type)
      },
      if ("ur" %in% input$demog) {
        process_data(dff(), outcome(), input$recode, "ur", "Place of\nResidence",
                     input$weight_type)
      }
    ))

    validate(
      need(dta_mover, "Error: no data available. Please verify that this question was asked in this country/year combination")
    )

    dta_mover$vallabel <- as.character(dta_mover$vallabel)
    return(dta_mover)
  })


  moverg <- reactive({
    moverg <- lapop_mover(moverd(),
                          subtitle = "% in selected category",
                          ymax = ifelse(any(moverd()$prop > 90, na.rm = TRUE), 119,
                                        ifelse(any(moverd()$prop > 80, na.rm = TRUE), 109, 100)),
                          source_info = "Source: CSES Data Playground")
    return(moverg)
  })

  output$mover <- renderPlot({
    return(moverg())
  })

# # -----------------------------------------------------------------------
# DOWNLOAD SECTION
# # -----------------------------------------------------------------------

# Download Plot
# # -----------------------------------------------------------------------
  output$downloadPlot <- downloadHandler(
    filename = function(file) {

      weight_suffix <- switch(input$weight_type, # Add weight type to plot export
                              "no_weight" = "unweighted",
                              "weight_demographic" = "demogweighted",
                              "weight_sample" = "sampleweighted")

      ifelse(input$tabs == "Histogram", paste0("hist_", outcome(), "_", weight_suffix, ".svg"),
             ifelse(input$tabs == "Time Series",  paste0("ts_", outcome(), "_", weight_suffix, ".svg"),
                    ifelse(input$tabs == "Cross Country",  paste0("cc_", outcome(), "_", weight_suffix, ".svg"),
                           ifelse(input$tabs == "World Map",  paste0("map_", outcome(), "_", weight_suffix, ".svg"),
                                  paste0("mover_", outcome(), "_", weight_suffix, ".svg"))))) # Add plot type to file export
    },

    content = function(file) {

      if(input$tabs == "Histogram") {
        title_text <- isolate(cap())
        word_text <- isolate(word())

        hist_to_save <- lapop_hist(histd(),
                                   main_title = title_text,
                                   subtitle = "% in selected category ",
                                   ymax = ifelse(any(histd()$prop > 90), 110, 100),
                                   source_info = source_info_both()
        )

        lapop_save(hist_to_save, file)
        showNotification(HTML("Histogram plot download complete ✓ "), type = "message")

      } else if (input$tabs == "Time Series") {
        title_text <- isolate(cap())
        subtitle_text <- slider_values()

        ts_to_save <-  lapop_ts(tsd(),
                                main_title = title_text,
                                subtitle = paste0("% in selected category ", subtitle_text),
                                ymax = ifelse(any(tsd()$prop > 88, na.rm = TRUE), 110, 100),
                                label_vjust = ifelse(any(tsd()$prop > 80, na.rm = TRUE), -1.1, -1.5),
                                source_info = source_info_pais()
        )

        lapop_save(ts_to_save, file)
        showNotification(HTML("Time series plot download complete ✓ "), type = "message")

      } else if (input$tabs == "Cross Country") {
        title_text <- isolate(cap())
        subtitle_text <- slider_values()

        cc_to_save <- lapop_cc(ccd(), sort = "hi-lo",
                               main_title = title_text,
                               subtitle = paste0("% in selected category ", subtitle_text),
                               ymax = ifelse(any(ccd()$prop > 90, na.rm = TRUE), 110, 100),
                               label_angle = 90,
                               source_info = source_info_wave()
        )

        lapop_save(cc_to_save, file)
        showNotification(HTML("Cross country plot download complete ✓ "), type = "message")

      } else if (input$tabs == "World Map") {
        title_text <- isolate(cap())
        subtitle_text <- slider_values()

        map_to_save <- lapop_map(mapd(),
                               main_title = title_text,
                               subtitle = paste0("% in selected category ", subtitle_text),
                               source_info = paste0("\n", source_info_both()),
                               survey = "CSES"
        )

        lapop_save(map_to_save, file)
        showNotification(HTML("Map plot download complete ✓ "), type = "message")

      } else {
        title_text <- isolate(cap())
        subtitle_text <- slider_values()
        word_text <- isolate(word())

        mover_to_save <- lapop_mover(
          moverd(),
          main_title = title_text,
          subtitle = paste0("% in selected category ", subtitle_text),
          ymax = ifelse(any(moverd()$prop > 90, na.rm = TRUE), 119,
                        ifelse(any(moverd()$prop > 80, na.rm = TRUE), 109, 100)),
          source_info = source_info_both()
        )

        lapop_save(mover_to_save, file)
        showNotification(HTML("Break down plot download complete ✓ "), type = "message")

      }
    }
  )

# DOWNLOAD TABLE
 # -----------------------------------------------------------------------
  output$downloadTable <- downloadHandler(
    filename = function(file) {

      weight_suffix <- switch(input$weight_type, # Add weight type to file export
                              "no_weight" = "unweighted",
                              "weight_demographic" = "demogweighted",
                              "weight_sample" = "sampleweighted")

      ifelse(input$tabs == "Histogram", paste0("hist_", outcome(), "_", weight_suffix, ".csv"),
             ifelse(input$tabs == "Time Series",  paste0("ts_", outcome(), "_", weight_suffix,".csv"),
                    ifelse(input$tabs == "Cross Country",  paste0("cc_", outcome(), "_", weight_suffix, ".csv"),
                           ifelse(input$tabs == "World Map",  paste0("map_", outcome(), "_", weight_suffix, ".csv"),
                                  paste0("mover_", outcome(), "_", weight_suffix, ".csv")))))
    },
    content = function(file) {
      if(input$tabs == "Histogram") {
        write.csv(histd(), file, row.names=F)
        showNotification(HTML("Histogram file download complete ✓ "),
                         type = "message")

      } else if (input$tabs == "Time Series") {
        write.csv(tsd(), file, row.names=F)
        showNotification(HTML("Time series file download complete ✓ "),
                         type = "message")

      } else if (input$tabs == "Cross Country") {
        write.csv(ccd(), file, row.names=F)
        showNotification(HTML("Cross country file download complete ✓ "),
                         type = "message")

      } else if (input$tabs == "World Map") {
        write.csv(mapd(), file, row.names=F)
        showNotification(HTML("Map file download complete ✓ "),
                         type = "message")

      } else {
        write.csv(moverd(), file, row.names=F)
        showNotification(HTML("Break down file download complete ✓ "),
                         type = "message")

      }
    }
  )
}

# RUN APP
# # -----------------------------------------------------------------------
shinyApp(ui, server)

# # -----------------------------------------------------------------------
# END
# # -----------------------------------------------------------------------