app_dir <- tryCatch(
  if (nzchar(Sys.getenv("R_BUNDLE_APP"))) getwd()
  else dirname(rstudioapi::getActiveDocumentContext()$path),
  error = function(e) getwd()
)

library(RDesk)

# Dynamically source all backend modules
lapply(
  list.files(file.path(app_dir, "R"), pattern = "\\.R$", full.names = TRUE),
  source
)

app <- App$new(
  title  = "My RDesk App",
  width  = 1100L,
  height = 740L,
  www    = file.path(app_dir, "www")
)

init_handlers(app)
app$run()

app$on_message("compute_stats", async(function(payload) {
  # Executed inside an isolated background worker process
  # DO NOT call app$ methods inside this closure
  # DO NOT access global variables; pass them via payload or capture them explicitly
  df <- load_raw_data(payload$source)
  result <- run_calculation(df)
  list(stats = result)
}, app = app, loading_message = "Processing calculation..."))

app$on_message("heavy_loop", async(function(payload) {
  steps <- payload$steps
  for (i in seq_along(steps)) {
    process_step(steps[[i]])
    async_progress(
      value   = round(i / length(steps) * 100),
      message = paste("Processing step", i, "of", length(steps))
    )
  }
  list(complete = TRUE)
}, app = app))

job_id <- rdesk_async(
  task     = function(x) run_heavy(x),
  args     = list(x = data),
  on_done  = function(res) app$send("done", res),
  on_error = function(err) app$toast(err$message, type = "error")
)
app$loading_start("Running...", cancellable = TRUE, job_id = job_id)

m <- mirai::mirai(
  slow_function(x),
  slow_function = slow_function,
  x = input_data
)

# In R/plots.R
generate_trend_plot <- function(df) {
  p <- ggplot2::ggplot(df, ggplot2::aes(x = date, y = value)) +
    ggplot2::geom_line(colour = "#1a1a2e", linewidth = 1) +
    ggplot2::theme_minimal()
  rdesk_plot_to_base64(p)
}

# In R/server.R handler
app$on_message("get_trend", function(payload) {
  df <- load_data()
  list(chart = generate_trend_plot(df))
})

# In R/server.R handler
app$on_message("get_raw_table", function(payload) {
  df <- head(mtcars)
  rdesk_df_to_list(df)
})

# --- 1. SHINY ORIGINAL (server.R) ---
server <- function(input, output, session) {
  filtered <- reactive({
    mtcars[mtcars$cyl == input$cyl_filter, ]
  })
  output$scatter <- renderPlot({
    ggplot2::ggplot(filtered(), ggplot2::aes(wt, mpg)) + ggplot2::geom_point()
  })
  output$table <- renderTable({ filtered() })
}

# --- 2. RDESK REWRITE (R/server.R) ---
init_handlers <- function(app) {
  app$on_ready(function() {
    app$send("data_ready", rdesk_df_to_list(mtcars))
  })

  app$on_message("filter_changed", async(function(payload) {
    df <- mtcars[mtcars$cyl == payload$cyl_filter, ]
    p  <- ggplot2::ggplot(df, ggplot2::aes(wt, mpg)) + ggplot2::geom_point()
    list(
      chart = rdesk_plot_to_base64(p),
      table = rdesk_df_to_list(df)
    )
  }, app = app))
}

// --- 3. RDESK FRONTEND (www/js/app.js) ---
rdesk.ready(function() {
  rdesk.send("get_data", {});
});

document.getElementById("cyl-filter").addEventListener("change", function() {
  rdesk.send("filter_changed", { cyl_filter: parseInt(this.value) });
});

rdesk.on("filter_changed_result", function(data) {
  document.getElementById("chart").src = "data:image/png;base64," + data.chart;
  renderTable(data.table.rows, data.table.cols);
});

# WRONG
app$on_message("task", async(function(payload) {
  res <- run_calculation(payload)
  app$toast("Task Completed!")  # ERROR: app$ is not available in isolated worker processes
  list(data = res)
}, app = app))

# CORRECT
app$on_message("task", async(function(payload) {
  res <- run_calculation(payload)
  list(data = res)  # Return value is pushed automatically to task_result
}, app = app))

# WRONG
dataset <- load_heavy_data()
app$on_message("run", async(function(payload) {
  process(dataset)  # ERROR: dataset is not bound in the worker process environment
}, app = app))

# CORRECT
dataset <- load_heavy_data()
app$on_message("run", async(function(payload) {
  process(payload$data)  # Pass the object explicitly via payload
}, app = app))

# OR
local_data <- dataset
app$on_message("run", async(function(payload) {
  process(local_data)  # Captured in the closure, serialised to the worker
}, app = app))

# WRONG - Output might buffer in compiled desktop mode
cat(jsonlite::toJSON(msg), "\n")

# CORRECT - Always flush stdout after writing low-level console logs
cat(jsonlite::toJSON(msg), "\n")
flush(stdout())

# WRONG - Violates CRAN policy
RDesk::build_app(app_dir = "MyApp", out_dir = "dist")

# CORRECT - Always write files inside tempdir()
RDesk::build_app(app_dir = "MyApp", out_dir = file.path(tempdir(), "dist"))

# WRONG - Extremely slow and violates CRAN guidelines
if ("ggplot2" %in% installed.packages()[,"Package"]) { ... }

# CORRECT - Fact-based, fast package checking
if (requireNamespace("ggplot2", quietly = TRUE)) { ... }

# WRONG
setwd(build_dir)
# ... tasks ...
setwd(original_dir) # Never executes if an error occurs mid-task

# CORRECT
old_wd <- getwd()
on.exit(setwd(old_wd), add = TRUE)
setwd(build_dir)

options(rdesk.ci_mode = TRUE)
library(RDesk)

# Source Server handlers and mock dynamic events
source("R/server.R")
# Handlers are initialized without spawning a physical WebView2 window

# Create scaffolding
rdesk_create_app("MyApp")

# Core Window Setup
app <- App$new(title = "App", width = 1100L, height = 740L, www = "www/")
app$on_ready(function() { ... })
app$on_message("msg_type", function(payload) { list(...) })
app$run()

# Server-Side Push
app$send("type", list(key = value))

# Dialogs
app$dialog_open(title = "Open File", filters = "CSV (*.csv)|*.csv")
app$dialog_save(title = "Save File", filters = "CSV (*.csv)|*.csv", default = "data.csv")
app$dialog_folder(title = "Select Export Folder")

# System Control
app$toast("message", type = "success|error|info|warning")
app$notify("Title", "Body Text")
app$maximize()
app$quit()

# Loading States
app$loading_start("Message...", cancellable = TRUE, job_id = "job_1")
app$loading_progress(50)
app$loading_done()

# Async Operations
rdesk_async(task, args, on_done, on_error)
rdesk_cancel_job("job_id")
rdesk_jobs_pending()

// Send data to R, returns Promise
rdesk.send("msg_type", { payload_key: "value" })
  .then(res => { ... })
  .catch(err => { ... });

// Listen for push notifications from R
rdesk.on("push_type", function(data) { ... });

// Run when the browser bridge is active
rdesk.ready(function() { ... });

// Deregister listener
rdesk.off("push_type");