box::use(
  shiny[...],
  bslib[...]
)

options(box.path = here::here())
box::use(
  modules/db,
  modules/utils,
  app/forms
)

#' @export
server <- function(id, values, scheme, mhcs) {

  ns <- NS(id)

  moduleServer(id, function(input, output, session) {

    # BOOKMARKS SETUP ========================
    # observe({
    #   # print(values$current_user)
    # })

    # functions -------------------
    ## new tasks ----------------
    get_default_task <- function() {

      tibble::tibble(
        task_id = paste0(format(Sys.time(), "%Y%m%d%H%M%S"), "_", values$main_key),
        task_main_key = values$main_key,
        task_status = "active",
        task_title = "НОВАЯ ЗАДАЧА",
        task_description = "",
        task_due_date = NA,
        task_user_created = values$current_user,
        task_datetime_created = Sys.time(),
        task_user_last_updated = NA,
        task_datetime_last_updated = NA,
        task_user_completed = NA,
        task_datetime_completed = NA
      )
    }

    # logic ---------------------
    ## modal fun -----
    show_modal_for_tasks <- function() {

      if (!is.null(values$tasks_data)) {

        tasks_selector <- values$tasks_data |>
          dplyr::filter(task_status != "completed") |>
          dplyr::pull(task_id)

        tasks_selector <- unique(c(values$tasks_id, tasks_selector))
        tasks_selector <- sort(tasks_selector)

        if (length(values$tasks_id) == 0) {
          values$tasks_id <- if (length(tasks_selector) == 0) NULL else tasks_selector[[1]]
        }

      } else {

        tasks_selector <- NULL

      }

      # ui --------------------
      # очень большой костыль
      subroup_scheme <- mhcs()$get_scheme("tasks") |>
        dplyr::filter(form_id != "dummy")

      tab <- if (length(tasks_selector) > 0) {
        bslib::nav_panel(
          title = "no name provided",
          purrr::pmap(
            .l = dplyr::distinct(subroup_scheme, form_id, form_label, form_type),
            .f = utils$render_forms,
            main_scheme = subroup_scheme,
            ns = ns
          )
        )
      } else {
        bslib::nav_panel("", div("Нет доступных записей.", br(), "Необходимо создать новую запись."))
      }

      ui <- layout_sidebar(
        sidebar = tagList(
          selectizeInput(ns("tasks_id_selector"), label = "ID задачи:", choices = tasks_selector, selected = values$tasks_id),
          actionButton(ns("tasks_create_new_task"), "Новая задача", icon("plus")),
          actionButton(ns("tasks_add_autoreview"), "Новая авто-задача (тест)", icon("calendar")),
          actionButton(ns("tasks_DT_VIEW"), "DT", icon("table"))
        ),
        tab
      )
    
      showModal(modalDialog(
        ui,
        size = "l",
        footer = tagList(
          actionButton(ns("tasks_saving_button"), "Сохранить изменения", icon("floppy-disk"))
        ),
        easyClose = TRUE
      ))
    }

    ## отображение окна -----------------
    observeEvent(input$display_task_modal, {
      
      if (is.null(values$main_key)) {
        showNotification("необходимо выбрать запись", type = "error")
        return()
      }

      con <- db$make_db_connection(scheme(),"display_task_modal")
      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)

      values$tasks_data <- if ("tasks" %in% DBI::dbListTables(con)) {
        DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_main_key = '{values$main_key}'")) |>
          dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
          dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))
      } else {
        NULL
      }

      values$tasks_id <- NULL
      show_modal_for_tasks()

    })

    ## изменение выбранной задачи -------
    observeEvent(input$tasks_id_selector, {
      req(input$tasks_id_selector)
      req(values$tasks_id)

      # выбранный ключ в форме - перемещаем в RV
      values$tasks_id <- input$tasks_id_selector

    })

    ## обновление формы при измененнии id ключа ------
    observeEvent(values$tasks_id, {

      df <- values$tasks_data |>
        dplyr::filter(task_id == values$tasks_id)

      forms$load_data_to_form(
        df         = df,
        table_name = "tasks",
        mhcs
        # ns = ns
      )
    })

    ## saving button ------------------------------
    observeEvent(input$tasks_saving_button, {

      con <- db$make_db_connection(scheme(),"tasks_saving_button")
      on.exit(db$close_db_connection(con, "tasks_saving_button"), add = TRUE)

      id_and_types_list <- mhcs()$get_id_type_list("tasks")
      input_types   <- unname(id_and_types_list)
      input_ids     <- names(id_and_types_list)

      exported_values <- purrr::map2(
        .x = input_ids,
        .y = input_types,
        .f = \(x_id, x_type) {

          input_d <- input[[x_id]]

          # return empty if 0 element
          if (length(input_d) == 0) {
            return(utils$get_empty_data(x_type))
          } else {
            input_d
          }
        }
      )

      exported_df <- stats::setNames(exported_values, input_ids) |>
        dplyr::as_tibble()

      df <- values$tasks_data

      df[df$task_id == values$tasks_id,]$task_status                <- exported_df$task_status
      df[df$task_id == values$tasks_id,]$task_title                 <- exported_df$task_title
      df[df$task_id == values$tasks_id,]$task_description           <- exported_df$task_description
      df[df$task_id == values$tasks_id,]$task_due_date              <- exported_df$task_due_date
      df[df$task_id == values$tasks_id,]$task_user_last_updated     <- values$current_user
      df[df$task_id == values$tasks_id,]$task_datetime_last_updated <- Sys.time()

      if (exported_df$task_status == "completed") {
        df[df$task_id == values$tasks_id,]$task_user_completed     <- values$current_user 
        df[df$task_id == values$tasks_id,]$task_datetime_completed <- Sys.time() 
      }

      values$tasks_data <- df

      if ("tasks" %in% DBI::dbListTables(con)) {
        query <- glue::glue("
          DELETE 
          FROM tasks 
          WHERE task_main_key = '{values$main_key}'
        ")
        DBI::dbExecute(con, query)
      }

      DBI::dbWriteTable(con, "tasks", df, append = TRUE)

      update_task_button_count(con, values)
      showNotification("Задача успешно создана/обновлена", type = "message")

      tasks_selector <- values$tasks_data |>
        dplyr::filter(task_status != "completed") |>
        dplyr::pull(task_id)

      selector <- ifelse(!values$tasks_id %in% tasks_selector, tasks_selector[1], values$tasks_id)

      updateSelectInput(inputId = "tasks_id_selector", choices = tasks_selector, selected = selector)

    })

    ## show DT --------------------------
    observeEvent(input$tasks_DT_VIEW, {

      rename_cols <- tasks_colnames[tasks_colnames %in% colnames(values$tasks_data)]
      
      date_cols <- c("task_datetime_created", "task_datetime_completed", "task_datetime_last_updated", "task_due_date")
      date_cols <- which(colnames(values$tasks_data) %in% date_cols)

      output$dt_tasks <- DT::renderDataTable(
        DT::datatable(
          values$tasks_data,
          caption = 'Table 1: This is a simple caption for the table.',
          rownames = FALSE,
          colnames = rename_cols,
          extensions = c('KeyTable', "FixedColumns"),
          # editable = 'cell',
          class = 'cell-border stripe',
          selection = "none",
          options = list(
            dom = 'tip',
            scrollX = TRUE,
            fixedColumns = list(leftColumns = 1),
            keys = TRUE,
            autoWidth = TRUE,
            columnDefs = list(
              list(
                targets = 3:4,
                width = '200px',
                render = htmlwidgets::JS(
                  "function(data, type, row, meta) {",
                  "return type === 'display' && data.length > 20 ?",
                  "'<span title=\"' + data + '\">' + data.substr(0, 20) + '...</span>' : data;",
                  "}")
              )
            )
          )
        ) |>
          DT::formatDate(date_cols, "toLocaleDateString", params = list('ru-RU'))
      )

      showModal(modalDialog(
        DT::dataTableOutput(ns("dt_tasks")),
        size = "xl",
        # footer = tagList(
        #   actionButton("nested_form_dt_save", "сохранить изменения")
        # ),
        easyClose = TRUE
      ))

    })

    ## создание новой задачи -------------
    observeEvent(input$tasks_create_new_task, {
      new_task <- get_default_task()
      
      values$tasks_data <- rbind(values$tasks_data, new_task)
      values$tasks_id <- new_task$task_id

      tasks_selector <- values$tasks_data |>
        dplyr::filter(task_status != "completed") |>
        dplyr::pull(task_id)

      updateSelectInput(inputId = "tasks_id_selector", choices = tasks_selector, selected = values$tasks_id)
      removeModal()
      show_modal_for_tasks()
    })
    
    ## создание новой авто-задачи -------------
    observeEvent(input$tasks_add_autoreview, {
      new_task <- get_default_task()

      new_task$task_title       <- "autoreview"
      new_task$task_description <- "напоминание об актуализации данных"
      new_task$task_due_date <- Sys.Date() + 28
      
      values$tasks_data <- rbind(values$tasks_data, new_task)
      values$tasks_id <- new_task$task_id

      tasks_selector <- values$tasks_data |>
        dplyr::filter(task_status != "completed") |>
        dplyr::pull(task_id)

      updateSelectInput(inputId = "tasks_id_selector", choices = tasks_selector, selected = values$tasks_id)
      removeModal()
      show_modal_for_tasks()
    })

    # review задач ----------------
    ### все активные задачи ------------
    observeEvent(input$show_dt_all, {

      con <- db$make_db_connection(scheme(),"display_task_modal")
      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)

      values$tasks_data <- DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_status = 'active'")) |>
        dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
        dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))

      display_tasks_dt_review()
    })

    ### задачи для текущего дня ------------
    observeEvent(input$show_dt_today, {

      con <- db$make_db_connection(scheme(),"display_task_modal")
      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)

      values$tasks_data <- DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_status = 'active' AND task_due_date = {as.integer(Sys.Date())}")) |>
        dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
        dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))

      display_tasks_dt_review()
    })

    ### просроченные ------------
    observeEvent(input$show_dt_overdue, {

      con <- db$make_db_connection(scheme(),"display_task_modal")
      on.exit(db$close_db_connection(con, "display_task_modal"), add = TRUE)

      values$tasks_data <- DBI::dbGetQuery(con, glue::glue("SELECT * FROM tasks WHERE task_status = 'active' AND task_due_date < {as.integer(Sys.Date())}")) |>
        dplyr::mutate(dplyr::across(c("task_datetime_created", "task_datetime_last_updated", "task_datetime_completed"), as.POSIXct)) |>
        dplyr::mutate(dplyr::across(c("task_due_date"), as.Date))

      display_tasks_dt_review()
    })

    ### modal -----
    display_tasks_dt_review <- function() {

      values$tasks_data <- values$tasks_data |>
        dplyr::select(task_id:task_datetime_last_updated)

      rename_cols <- tasks_colnames[tasks_colnames %in% colnames(values$tasks_data)]
      
      date_cols <- c("task_datetime_created", "task_datetime_completed", "task_datetime_last_updated", "task_due_date")
      date_cols <- which(colnames(values$tasks_data) %in% date_cols)

      output$dt_todays_tasks <- DT::renderDataTable(
        DT::datatable(
          values$tasks_data,
          caption = 'Table 1: This is a simple caption for the table.',
          rownames = FALSE,
          colnames = rename_cols,
          extensions = c("FixedColumns"),
          # editable = 'cell',
          selection = "single",
          options = list(
            dom = 'tip',
            scrollX = TRUE,
            fixedColumns = list(leftColumns = 1),
            autoWidth = TRUE,
            columnDefs = list(
              list(
                targets = 3:4,
                width = '200px',
                render = htmlwidgets::JS(
                  "function(data, type, row, meta) {",
                  "return type === 'display' && data.length > 20 ?",
                  "'<span title=\"' + data + '\">' + data.substr(0, 20) + '...</span>' : data;",
                  "}")
              )
            )
          )
        ) |>
        DT::formatDate(date_cols, "toLocaleDateString", params = list('ru-RU'))
      )

      showModal(modalDialog(
        DT::dataTableOutput(ns("dt_todays_tasks")),
        size = "xl",
        footer = tagList(
          actionButton(ns("jump_to_main_key"), "перейти к id", icon("right-to-bracket"))
        ),
        easyClose = TRUE
      ))

    }

    ### jump to main_key ---------
    observeEvent(input$jump_to_main_key, {

      if (is.null(input$dt_todays_tasks_rows_selected)) {
        showNotification("необходимо выбрать задачу", type = "error")
      } else {

        # get key
        new_main_key <- values$tasks_data[input$dt_todays_tasks_rows_selected,]$task_main_key
        values$main_key <- new_main_key

        showNotification("TODO: если ключа нет в таблице?!", type = "warning", duration = NULL)
        removeModal()

        # log_action_to_db("loading data", values$main_key, con = con)

      }
    })

  })
}

#' @export
update_task_button_count <- function(con, values, ns) {

  inputID <- "display_task_modal"
  if (!missing(ns)) inputID <- ns(inputID)
  

  # если ключ не определен - выход из функции
  if (is.null(values$main_key)) {

    updateActionButton(inputId = inputID, label = "Задачи")
    return()

  }

  # при наличии таблицы - полу
  if ("tasks" %in% DBI::dbListTables(con)) {

    tasks_num <- DBI::dbGetQuery(con, glue::glue("SELECT COUNT ('task_id') FROM tasks WHERE task_main_key = '{values$main_key}' AND task_status = 'active'")) |>
      dplyr::pull()

    if (tasks_num > 0) {
      updateActionButton(inputId = inputID, label = paste("активных задач:", tasks_num))
    } else {
      updateActionButton(inputId = inputID, label = "Задачи: нет активных")
    }
  }

}

tasks_colnames <- c(
  "id задачи"       = "task_id",
  "id записи"       = "task_main_key",
  "статус"          = "task_status",
  "задача"          = "task_title",
  "описание"        = "task_description",
  "срок выполнения" = "task_due_date",
  "создана"         = "task_user_created",
  "дата создания"   = "task_datetime_created",
  "обновлено"       = "task_user_last_updated",
  "дата обновления" = "task_datetime_last_updated",
  "завершено"       = "task_user_completed",
  "дата выполнения" = "task_datetime_completed"
)