# Install performance tools
# pak::pak(c("microbenchmark", "profvis", "bench", "palmerpenguins"))

# Core performance packages
library(microbenchmark)  # Micro-benchmarking
library(profvis)         # Profiling and visualization
library(bench)           # Modern benchmarking
library(palmerpenguins)  # Example data

library(data.table)
library(dplyr)

dt = as.data.table(penguins)

# Compare different approaches systematically
microbenchmark(
  base_approach = aggregate(body_mass_g ~ species, penguins, mean),
  dplyr_approach = penguins %>% 
    group_by(species) %>% 
    summarize(mean_mass = mean(body_mass_g, na.rm = TRUE)),
  data.table_approach = dt[, .(mean_mass = mean(body_mass_g, na.rm = TRUE)), by = species],
  times = 100
)

# DON'T DO THIS: Optimizing before understanding the problem
# Spending hours optimizing this:
fast_but_unreadable <- function(x) {
  .Call("C_fast_mean", x, PACKAGE = "mypackage")
}

# When this is fast enough and much clearer:
readable_solution <- function(x) {
  mean(x, na.rm = TRUE)
}

# UGLY: Unreadable "optimized" code
ugly_fast <- penguins[!is.na(body_mass_g), 
                     .(m=.Internal(mean(body_mass_g))), 
                     keyby=.(s=species)]

# GOOD: Clear, maintainable code that's fast enough
clear_code <- penguins %>%
  filter(!is.na(body_mass_g)) %>%
  group_by(species) %>%
  summarize(mean_mass = mean(body_mass_g))

library(profvis)

# set up fake large data
pen2 = replicate(10000, penguins, simplify = FALSE) |> 
  bind_rows() |> 
  mutate(species = paste(species, 1:1000))

# Profile a more complex operation
profvis({
  # Simulate some data processing
  results <- pen2 |> 
    filter(!is.na(bill_length_mm)) |> 
    group_by(species, island) |> 
    summarize(
      mean_bill = mean(bill_length_mm),
      sd_bill = sd(bill_length_mm),
      .groups = "drop"
    ) |> 
    arrange(desc(mean_bill))
})

# High readability, adequate performance
readable_analysis <- penguins %>%
  filter(!is.na(bill_length_mm), !is.na(body_mass_g)) %>%
  mutate(bill_to_mass_ratio = bill_length_mm / body_mass_g) %>%
  group_by(species) %>%
  summarize(
    mean_ratio = mean(bill_to_mass_ratio),
    median_ratio = median(bill_to_mass_ratio),
    n_observations = n()
  )

# Versus optimized but less readable version...
idx <- !is.na(penguins$bill_length_mm) & !is.na(penguins$body_mass_g)
s <- penguins$species[idx]
r <- penguins$bill_length_mm[idx] / penguins$body_mass_g[idx]
sl <- split(r, s)

very_ugly_analysis <- data.frame(
  species = names(sl),
  mean_ratio = vapply(sl, mean, numeric(1)),
  median_ratio = vapply(sl, median, numeric(1)),
  n_observations = vapply(sl, length, integer(1))
)

# GOOD: Clear intent, logical flow
analyze_penguin_measures <- function(data, measurement_var) {
  data %>%
    filter(!is.na({{measurement_var}})) %>%
    group_by(species, island) %>%
    summarize(
      mean_value = mean({{measurement_var}}, na.rm = TRUE),
      std_dev = sd({{measurement_var}}, na.rm = TRUE),
      sample_size = n(),
      .groups = "drop"
    ) %>%
    arrange(species, island)
}

# Usage is self-documenting
bill_analysis <- analyze_penguin_measures(penguins, bill_length_mm)
mass_analysis <- analyze_penguin_measures(penguins, body_mass_g)

# BAD: Unclear purpose, complex logic
f <- function(d, v) {
  d[!is.na(d[[deparse(substitute(v))]]), ] %>%
    split(paste(d$species, d$island)) %>%
    map_dfr(~ data.frame(
      grp = .x$species[1], 
      isl = .x$island[1],
      m = mean(.x[[deparse(substitute(v))]]),
      s = sd(.x[[deparse(substitute(v))]]),
      n = nrow(.x)
    ))
}

# What does this do? How do I use it?
result <- f(penguins, bill_length_mm)  # Unclear!

# Show students the progression:

# 1. Inefficient but clear
slow_approach <- function(data) {
  results <- data.frame()
  for(species in unique(data$species)) {
    subset_data <- data[data$species == species, ]
    mean_mass <- mean(subset_data$body_mass_g, na.rm = TRUE)
    results <- rbind(results, data.frame(species = species, mean_mass = mean_mass))
  }
  return(results)
}

# 2. Efficient and still clear
fast_approach <- function(data) {
  data %>%
    group_by(species) %>%
    summarize(mean_mass = mean(body_mass_g, na.rm = TRUE))
}

# Install multilingual tools
# pak::pak(c("reticulate", "arrow", "palmerpenguins"))

# Setup Python environment
library(reticulate)
library(arrow)

# Modern 2025 approach: automatic Python setup
py_require(c("pandas", "numpy", "pyarrow"))

# R: Prepare data as Arrow table
library(arrow)
penguins_arrow <- arrow_table(penguins)

# Pass to Python (zero-copy!)
py$penguins_data <- penguins_arrow

# Python chunk processes data

# Python: Work with the data
import pandas as pd

# Convert from Arrow (still efficient)
df = r.penguins_data.to_pandas()

# Python-specific analysis
from sklearn.cluster import KMeans
# ... machine learning code ...

# Return results to R
processed_data = df.groupby('species').mean()

# R: Statistical modeling
library(broom)

model_results <- penguins %>%
  filter(!is.na(bill_length_mm), !is.na(body_mass_g)) %>%
  nest_by(species) %>%
  mutate(
    model = list(lm(body_mass_g ~ bill_length_mm, data = data)),
    tidy_results = list(tidy(model))
  )

# Python: Machine learning on same data
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split

# Use the R data directly
X = r.penguins[['bill_length_mm', 'bill_depth_mm']].dropna()
y = r.penguins['body_mass_g'].dropna()

# Train model
rf_model = RandomForestRegressor()
rf_model.fit(X, y)

# R: Data preparation and exploration
library(palmerpenguins)
library(ggplot2)

# Exploratory analysis in R
penguins %>%
  ggplot(aes(bill_length_mm, body_mass_g, color = species)) +
  geom_point() +
  labs(title = "Penguin Measurements by Species")

# Pass cleaned data to Python for ML
py$clean_penguins <- penguins %>%
  drop_na() %>%
  select(bill_length_mm, bill_depth_mm, flipper_length_mm, body_mass_g, species)

# Python: Machine learning pipeline
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

# Use R's cleaned data
df = r.clean_penguins
X = df[['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm', 'body_mass_g']]
y = df['species']

# Train classifier
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
clf = RandomForestClassifier()
clf.fit(X_train, y_train)

# Return predictions to R
predictions = clf.predict(X_test)