# 1. Create your template (see Step 1 below for details)
# inst/mypackage_config_template.yml

# 2. In your R/zzz.R - choose your strategy:
.onLoad <- function(libname, pkgname) {
  icy::create_local()  # Creates user's local config from template
}

# 3. In your package functions - access config:
get_api_key <- function() {
  config <- icy::get_config(origin = "local")  # File-based approach
  return(config$MYPACKAGE_API_KEY)
}

# 4. Expose configuration to users:
configure_mypackage <- function() {
  icy::setup()  # Interactive configuration for all variables
}

# In your R/zzz.R file
.onLoad <- function(libname, pkgname) {
  # This creates ~/.local/share/R/dummy/dummy_config_local.yml if it doesn't exist
  icy::create_local()
  
  # Now users can edit their local config and it persists between sessions
}

# In your package functions
get_my_api_key <- function() {
  config <- icy::get_config(origin = "priority")  # Checks .Renviron > local
  return(config$DUMMY_API_KEY)
}

# Interactive configuration for users
configure_package <- function() {
  icy::qconfig("DUMMY_API_KEY")      # Interactive with template integration
  icy::qconfig("DUMMY_VERBOSE")      # Automatic boolean detection (TRUE/FALSE options)
}

# In your R/zzz.R file
.onLoad <- function(libname, pkgname) {
  # Load config into R session environment variables
  icy::load_config(
    origin = "priority",  # .Renviron > local > template
    unset = list(         # Fallbacks for missing values
      DUMMY_API_KEY = "demo-key-12345",
      DUMMY_TIMEOUT = 30
    )
  )
}

# In your package functions  
get_my_api_key <- function() {
  return(Sys.getenv("DUMMY_API_KEY"))  # Standard R approach
}

# User can see current settings
icy::show_config(package = "dummy")

# User can modify local settings (traditional approach)
icy::write_local(
  package = "dummy",
  var_list = list(DUMMY_API_KEY = "my-real-key")
)

# Or use interactive configuration (user-friendly)
icy::qconfig("DUMMY_API_KEY", package = "dummy")    # Prompts with template options
icy::qconfig("DUMMY_VERBOSE", package = "dummy")    # Automatic TRUE/FALSE options for boolean types

# User can set global settings (affects all projects)
icy::write_renviron(
  package = "dummy",
  var_list = list(DUMMY_API_KEY = "global-key")
)

# Changes take effect immediately in session environment
icy::sync(package = "dummy")

library(icy)

# See all variables and where they come from
show_config(package = "dummy")
# Output shows:
# DUMMY_API_KEY: "my-secret" (from: .Renviron)
# DUMMY_DB_HOST: "localhost" (from: local config)  
# DUMMY_DEBUG: FALSE (from: template)

# Check what's in each source individually
template_values <- get_config(package = "dummy", origin = "template")
local_values <- get_config(package = "dummy", origin = "local") 
renviron_values <- get_config(package = "dummy", origin = "renviron")

# See the final merged result (priority: .Renviron > local > template)
final_config <- get_config(package = "dummy", origin = "priority")

# Your package's .onLoad() (in R/zzz.R)
.onLoad <- function(libname, pkgname) {
  icy::create_local()  # Creates local config from template automatically
}

# Provide a dedicated setup function for users
setup_dummy <- function() {
  message("Welcome to dummy package configuration!")
  
  # Use icy's interactive setup - walks through all variables
  icy::setup()
  
  message("\nConfiguration complete! Your settings are saved locally.")
  message("Run show_dummy_config() anytime to view your settings.")
}

# Individual configuration functions for specific needs
configure_api_key <- function() {
  icy::qconfig("DUMMY_API_KEY")  # Interactive with validation
}

configure_directories <- function() {
  icy::qconfig("DUMMY_DATA_DIR", type = "path")  # With directory creation
}

# Advanced: Targeted setup for critical variables
setup_essentials <- function() {
  icy::setup(
    vars = c("DUMMY_API_KEY", "DUMMY_DB_HOST"),
    allow_skip = c(FALSE, TRUE)  # API key required, DB host optional
  )
}

# Users then have a smooth experience:
# library(dummy)           # Local config created automatically  
# setup_dummy()            # Interactive configuration for all variables
# setup_essentials()       # Just the critical ones
# configure_api_key()      # Individual settings as needed

# Set a global API key for all projects
icy::write_renviron(
  var_list = list(
    DUMMY_API_KEY = "my-global-key-for-all-projects"
  ),
  package = "dummy"  # Still validates against dummy's template
)

# This goes in ~/.Renviron and affects ALL R sessions
# Priority: .Renviron beats local config

# Development setup
dev_config <- get_config(
  package = "dummy",
  section = "development",  # Uses the "development" section from template
  origin = "template"
)

# User can override with local development settings
write_local(
  var_list = list(
    DUMMY_DB_HOST = "my-local-dev-db.internal",
    DUMMY_DEBUG = TRUE
  ),
  package = "dummy"
  # This goes in the "default" section of local config
)

# For production, user might set global .Renviron
write_renviron(
  var_list = list(
    DUMMY_DB_HOST = "prod-db.company.com",
    DUMMY_DEBUG = FALSE
  ),
  package = "dummy"
)

# get_config() ALWAYS reads from files - never affected by session sync
file_config <- get_config(package = "dummy", origin = "local")
print(file_config$DUMMY_API_KEY)  # Reads current file value

# Sys.getenv() reads from R session environment
session_value <- Sys.getenv("DUMMY_API_KEY")  # May be different from file

# When you write_local(), the FILE is updated immediately
write_local(
  var_list = list(DUMMY_API_KEY = "new-key"),
  package = "dummy",
  sync = "none"  # Don't sync to session
)

# File updated, but session unchanged
print(get_config(package = "dummy")$DUMMY_API_KEY)  # "new-key" (from file)
print(Sys.getenv("DUMMY_API_KEY"))                  # Still old value (session)

# Sync options control SESSION environment updates:
write_local(
  var_list = list(DUMMY_VERBOSE = TRUE),
  package = "dummy",
  sync = "all"  # Update session immediately
)

# Now both file and session are updated
print(get_config(package = "dummy")$DUMMY_VERBOSE)  # TRUE (from file)
print(Sys.getenv("DUMMY_VERBOSE"))                  # "TRUE" (session)

# Manual session sync when needed
icy::sync(package = "dummy", var_names = "DUMMY_API_KEY")
print(Sys.getenv("DUMMY_API_KEY"))  # Now updated in session

# See what variables are configured
var_names <- names(get_config(package = "dummy"))

# Remove from .Renviron (global reset)
erase_renviron(var_names, package = "dummy")

# Could also reset local config by overwriting with template values
template_defaults <- get_config(package = "dummy", origin = "template")
write_local(var_list = template_defaults, package = "dummy")

# Apply changes to current session
sync(package = "dummy", var_names = var_names)

# Turn on verbose mode to see what icy is doing
toggle_verbose(package = "dummy")

# Turn on debug mode for even more details
toggle_debug(package = "dummy") 

# Now icy functions will be much more chatty
config <- get_config(package = "dummy", origin = "priority", verbose = TRUE)

# Validate that your variable names are correct
validate(
  package = "dummy",
  var_names = c("DUMMY_API_KEY", "DUMMY_TYPO_VAR")  # Will catch the typo
)

# Check if files exist where expected
local_path <- find_local(package = "dummy")
template_path <- find_template(package = "dummy")
print(c(local = local_path, template = template_path))

# Partial filename matching
icy::qconfig("API_KEY", fn_tmpl = "dummyRunTemplat", package = "dummy")
# icy detects "dummyRunTemplate.yml" exists and asks:
# "No exact match for 'dummyRunTemplat'. Found 'dummyRunTemplate.yml'. Use this instead?"
# After confirmation, creates corresponding "dummyRunLocal.yml"

# Works for both template and local files
icy::setup(fn_local = "myConfigLocal", package = "dummy")
# Finds "myConfigTemplate.yml" and asks for confirmation

# Create simple wrappers for common configuration tasks
set_api_key <- function(key = NULL) {
  if (is.null(key)) {
    # Interactive mode
    icy::qconfig("MYPACKAGE_API_KEY")
  } else {
    # Programmatic mode
    icy::write_local(list(MYPACKAGE_API_KEY = key))
    message("API key configured successfully")
  }
}

# Complete package setup function
setup_mypackage <- function(interactive = TRUE) {
  if (interactive) {
    message("Welcome to MyPackage configuration!")
    icy::setup()  # Full interactive setup
  } else {
    # Non-interactive: just ensure local config exists
    icy::create_local()
  }
}

# Configuration viewing function
show_mypackage_config <- function() {
  icy::show_config(display = "values")
  message("\nTo modify settings, run setup_mypackage() or set_api_key()")
}

# Validation function for critical settings
validate_mypackage_config <- function() {
  config <- icy::get_config(origin = "priority")
  
  # Check required settings
  if (is.null(config$MYPACKAGE_API_KEY) || config$MYPACKAGE_API_KEY == "your-api-key-here") {
    stop("API key not configured. Run set_api_key() to configure.")
  }
  
  # Validate settings
  if (!is.logical(config$MYPACKAGE_VERBOSE)) {
    warning("MYPACKAGE_VERBOSE should be TRUE or FALSE")
  }
  
  return(config)
}

# Export these functions in your NAMESPACE for users:
# export(set_api_key, setup_mypackage, show_mypackage_config)

# Option 1: get_config() - Returns merged list (does NOT modify session)
config <- icy::get_config(origin = "priority")
api_key <- config$MY_PACKAGE_API_KEY  # Extract from returned list

# Getting a specific value (common patterns):
api_key <- icy::get_config(origin = "priority")$MY_PACKAGE_API_KEY  # Direct access
debug_mode <- icy::get_config(origin = "local")$MY_PACKAGE_DEBUG    # From local only

# With error checking for missing values:
config <- icy::get_config(origin = "priority")
if (is.null(config$MY_PACKAGE_API_KEY)) {
  stop("API key not configured. Run setup() to configure.")
}

# Option 2: load_config() - Sets environment variables (modifies session)
icy::load_config(origin = "priority")  # Uses Sys.setenv() internally
api_key <- Sys.getenv("MY_PACKAGE_API_KEY")  # Standard R environment access