# Function: compute_formula 
# Define a function to calculate values based on a specific mathematical formula
compute_formula <- function(x, formula) {
  # Define a list of accepted formula names
  valid_formulas <- c("linear", "quadratic", "cubic", "exponential")
  
  # Check if the provided formula is in the list of valid options; if not, stop and show an error
  if (!formula %in% valid_formulas) {
    stop(paste("Invalid formula '", formula,
               "'. Choose from:", paste(valid_formulas, collapse = ",")))}
  
  # Determine the calculation logic based on the formula type selected
  y <- if (formula == "linear")      { 2 * x + 1          }
  else if (formula == "quadratic")   { x^2 - 3 * x + 2    }
  else if (formula == "cubic")       { x^3 - 5 * x^2 + 4  }
  else                               { exp(0.3 * x)        }
  
  # Return the calculated result
  return(y)}

# Define a sequence of x values from 1 to 20
x_vals   <- 1:20

# Define the set of formulas to be processed
formulas <- c("linear", "quadratic", "cubic", "exponential")

# Initialize an empty data frame to store the results
results  <- data.frame()

# Iterate through each formula type
for (f in formulas) {
  # Iterate through each value in the x sequence
  for (x in x_vals) {
    # Call the function to calculate y for the current x and formula
    y <- compute_formula(x, f)
    
    # Append the results (Formula name, x value, and rounded y value) to the data frame
    results <- rbind(results, data.frame(Formula = f, x = x, y = round(y, 4)))}}

# Set the seed for reproducibility to ensure the random numbers are the same each time
set.seed(42)

# Define a function to calculate the running total (cumulative sum) of a vector
cumulative_sales <- function(sales_vector) {
  # Initialize an empty vector for cumulative values and a counter for the running total
  cum <- c(); total <- 0
  # Loop through each sales value in the input vector, add it to the total, and store it
  for (s in sales_vector) { total <- total + s; cum <- c(cum, total) }
  # Return the vector of cumulative sums
  return(cum)}

# Define a function to simulate sales data for multiple people over several days
simulate_sales <- function(n_salesperson, days) {
  # Initialize an empty data frame to store the final simulation results
  result <- data.frame()
  # Loop through the number of salespersons specified
  for (sp in 1:n_salesperson) {
    # Generate random daily sales amounts between 500 and 5000 and round them
    daily_sales <- round(runif(days, min = 500, max = 5000))
    # Calculate the cumulative sales for the current salesperson
    cum_sales   <- cumulative_sales(daily_sales)
    # Loop through each day to calculate discounts and store individual records
    for (d in 1:days) {
      # Get the sales amount for the current day
      amt <- daily_sales[d]
      # Determine the discount rate based on the amount: 20% for >4000, 10% for >2500, else 5%
      discount_rate <- if (amt > 4000) { 0.20 } else if (amt > 2500) { 0.10 } else { 0.05 }
      # Combine the data into a new row and append it to the main result data frame
      result <- rbind(result, data.frame(
        sales_id      = paste0("SP", sp, "_D", d),
        salesperson   = paste("Salesperson", sp),
        day           = d,
        sales_amount  = amt,
        discount_rate = discount_rate,
        net_sales     = round(amt * (1 - discount_rate)),
        cum_sales     = cum_sales[d]
      ))}}
  # Return the complete data frame containing all simulated records
  return(result)}

# Execute the simulation for 5 salespersons over 10 days and store the result
sales_data <- simulate_sales(n_salesperson = 5, days = 10)

# Define a function to assign a performance label based on sales amount
categorize_performance <- function(sales_amount) {
  # Initialize an empty vector to store the results
  categories <- c()
  # Loop through each sales figure provided in the input vector
  for (s in sales_amount) {
    # Determine the category based on specific threshold values
    cat <- if (s >= 4500)        "Excellent"
           else if (s >= 3500)  "Very Good"
           else if (s >= 2500)  "Good"
           else if (s >= 1500)  "Average"
           else                 "Poor"
    # Append the determined category to the results vector
    categories <- c(categories, cat)}
  # Return the complete vector of performance categories
  return(categories)}

# Extract the sales_amount column from the existing sales_data data frame
all_sales <- sales_data$sales_amount
# Apply the categorization function to all sales figures
perf_cats <- categorize_performance(all_sales)
# Create a new data frame pairing the original sales amounts with their new categories
perf_df   <- data.frame(sales_amount = all_sales, category = perf_cats)

# Summarize the performance data using the pipe operator
perf_summary <- perf_df %>%
  # Count the number of occurrences for each category
  count(category) %>%
  # Add a percentage column and convert category to a factor with a specific order
  mutate(
    percentage = round(n / sum(n) * 100, 1),
    category   = factor(category, levels = c("Excellent","Very Good","Good","Average","Poor"))) %>%
  # Sort the final summary table based on the category ranking
  arrange(category)

# Set the seed for reproducibility to ensure the random number generation is consistent
set.seed(2024)

# Define a function to generate simulated employee data for a specific number of companies and employees
generate_company_data <- function(n_company, n_employees) {
  # Create a vector of possible department names
  departments <- c("Finance","HR","IT","Marketing","Operations","Sales")
  # Initialize an empty data frame to collect all generated records
  all_data    <- data.frame()
  # Outer loop to iterate through each company
  for (c in 1:n_company) {
    # Inner loop to iterate through each employee within the current company
    for (e in 1:n_employees) {
      # Generate a random performance score between 50 and 100, rounded to 1 decimal place
      perf_score    <- round(runif(1, 50, 100), 1)
      # Generate a random KPI score between 55 and 100, rounded to 1 decimal place
      kpi_score     <- round(runif(1, 55, 100), 1)
      # Flag as "Yes" if the KPI score is above 90, otherwise "No"
      top_performer <- ifelse(kpi_score > 90, "Yes", "No")
      # Assign a salary range based on the performance score threshold
      base_salary   <- if (perf_score >= 85)      { round(runif(1, 9000, 15000)) }
                       else if (perf_score >= 70) { round(runif(1, 6000, 9000))  }
                       else                       { round(runif(1, 3000, 6000))  }
      # Create a data frame for the current employee and append it to the master data frame
      all_data <- rbind(all_data, data.frame(
        company_id        = paste0("C", c),
        employee_id       = paste0("C", c, "_E", e),
        department        = sample(departments, 1),
        salary            = base_salary,
        performance_score = perf_score,
        KPI_score         = kpi_score,
        top_performer     = top_performer
      ))}}
  # Return the full data frame containing all companies and employees
  return(all_data)}

# Call the function to generate data for 4 companies with 15 employees each
company_data    <- generate_company_data(n_company = 4, n_employees = 15)

# Summarize the generated data using the pipe operator
company_summary <- company_data %>%
  # Group the data by company ID to perform calculations per company
  group_by(company_id) %>%
  # Calculate various averages and totals for each group
  summarise(
    Avg_Salary      = round(mean(salary), 0),
    Avg_Performance = round(mean(performance_score), 2),
    Avg_KPI         = round(mean(KPI_score), 2),
    Max_KPI         = max(KPI_score),
    Top_Performers  = sum(top_performer == "Yes"),
    Total_Employees = n(),
    # Drop the grouping structure to return a standard data frame
    .groups = "drop")

# Set the seed for reproducibility to ensure the random points generated are the same every time
set.seed(99)

# Define a function to estimate the value of Pi using the Monte Carlo method
monte_carlo_pi <- function(n_points) {
  # Generate random x-coordinates between -1 and 1
  x <- runif(n_points, -1, 1)
  # Generate random y-coordinates between -1 and 1
  y <- runif(n_points, -1, 1)
  # Initialize a counter for points that fall inside the unit circle
  inside_circle    <- 0
  # Initialize a counter for points that fall within a specific small square (0 to 0.5 on both axes)
  inside_subsquare <- 0
  
  # Loop through every generated point to check its location
  for (i in 1:n_points) {
    # Calculate the distance of the point from the origin (0,0)
    dist <- sqrt(x[i]^2 + y[i]^2)
    # If the distance is 1 or less, the point is inside the circle; increment the counter
    if (dist <= 1) { inside_circle <- inside_circle + 1 }
    # Check if the point falls within the bounds of the smaller square (0, 0) to (0.5, 0.5)
    if (x[i] >= 0 && x[i] <= 0.5 && y[i] >= 0 && y[i] <= 0.5) {
      inside_subsquare <- inside_subsquare + 1}}
  
  # Estimate Pi: (Points in Circle / Total Points) * Area of the bounding square (4)
  pi_estimate <- 4 * inside_circle / n_points
  # Calculate the empirical probability of a point falling in the small square
  prob_subsq  <- inside_subsquare / n_points
  
  # Return a list containing the Pi estimate, counts, probability, and the raw coordinates/status
  list(pi_estimate = pi_estimate, inside_circle = inside_circle,
       n_points = n_points, prob_subsquare = round(prob_subsq, 4),
       x = x, y = y, in_circle = sqrt(x^2 + y^2) <= 1)}

# Execute the Monte Carlo simulation with 10,000 points and store the results in 'mc'
mc <- monte_carlo_pi(10000)

# Define a function to scale numeric columns to a range between 0 and 1 (Min-Max Normalization)
normalize_columns <- function(df) {
  # Identify the names of all columns in the data frame that are numeric
  num_cols <- names(df)[sapply(df, is.numeric)]
  # Create a copy of the original data frame to store the normalized values
  norm_df  <- df
  # Loop through each identified numeric column
  for (col in num_cols) {
    # Find the minimum value of the current column, ignoring missing values
    min_val        <- min(df[[col]], na.rm = TRUE)
    # Find the maximum value of the current column, ignoring missing values
    max_val        <- max(df[[col]], na.rm = TRUE)
    # Apply the normalization formula: (x - min) / (max - min)
    norm_df[[col]] <- (df[[col]] - min_val) / (max_val - min_val)}
  # Return the data frame with normalized numeric columns
  return(norm_df)}

# Define a function to standardize numeric columns using Z-score (mean = 0, std dev = 1)
z_score <- function(df) {
  # Identify the names of all numeric columns
  num_cols <- names(df)[sapply(df, is.numeric)]
  # Create a copy of the original data frame to store the standardized values
  z_df     <- df
  # Loop through each numeric column
  for (col in num_cols) {
    # Calculate the average (mean) of the current column
    mu         <- mean(df[[col]], na.rm = TRUE)
    # Calculate the standard deviation of the current column
    sigma      <- sd(df[[col]], na.rm = TRUE)
    # Apply the Z-score formula: (x - mean) / standard deviation
    z_df[[col]] <- (df[[col]] - mu) / sigma}
  # Return the data frame with standardized values
  return(z_df)}

# Select specific numeric columns from the existing company_data for processing
numeric_df <- company_data %>% select(salary, performance_score, KPI_score)
# Create a normalized version of the selected columns
norm_df    <- normalize_columns(numeric_df)
# Create a standardized (Z-score) version of the selected columns
z_df       <- z_score(numeric_df)

# Create a new feature-engineered data frame based on company_data
feat_df <- company_data %>%
  # Use mutate to add new categorical columns based on numeric thresholds
  mutate(
    # Categorize performance scores into four descriptive levels
    performance_category = case_when(
      performance_score >= 90 ~ "Exceptional",
      performance_score >= 75 ~ "Strong",
      performance_score >= 60 ~ "Moderate",
      TRUE                    ~ "Needs Improvement"),
    # Categorize salary amounts into four professional brackets
    salary_bracket = case_when(
      salary >= 12000 ~ "Senior",
      salary >= 7500  ~ "Mid-level",
      salary >= 4500  ~ "Junior",
      TRUE            ~ "Entry"))

# Set the seed for reproducibility to ensure the random generation remains consistent
set.seed(777)

# Generate simulated company data for 6 companies with 30 employees each using the predefined function
kpi_data  <- generate_company_data(n_company = 6, n_employees = 30)

# Initialize an empty vector to store the KPI tier for each employee
kpi_tier  <- c()

# Loop through every row of the generated kpi_data data frame
for (i in 1:nrow(kpi_data)) {
  # Extract the KPI score for the current employee (row)
  score    <- kpi_data$KPI_score[i]
  # Assign a tier label based on the KPI score thresholds
  tier     <- if (score >= 90) "Platinum" else if (score >= 75) "Gold"
              else if (score >= 60) "Silver" else "Bronze"
  # Append the determined tier to the kpi_tier vector
  kpi_tier <- c(kpi_tier, tier)}

# Add the tier vector to the data frame as a factor with a specific ordinal level
kpi_data$kpi_tier <- factor(kpi_tier, levels = c("Platinum","Gold","Silver","Bronze"))

# Create a summary table by grouping the data by company
kpi_summary <- kpi_data %>%
  # Group the rows by the company_id column
  group_by(company_id) %>%
  # Calculate summary metrics for each company
  summarise(
    # Calculate the average salary rounded to the nearest whole number
    Avg_Salary      = round(mean(salary), 0),
    # Calculate the average KPI score rounded to 2 decimal places
    Avg_KPI         = round(mean(KPI_score), 2),
    # Calculate the average performance score rounded to 2 decimal places
    Avg_Performance = round(mean(performance_score), 2),
    # Count the number of individuals flagged as "Yes" in the top_performer column
    Top_Performers  = sum(top_performer == "Yes"),
    # Count the number of individuals who achieved the "Platinum" KPI tier
    Platinum_Count  = sum(kpi_tier == "Platinum"),
    # Count the total number of employees in the company
    Total_Employees = n(),
    # Remove the grouping structure after the summary is complete
    .groups = "drop")

# Define a function to generate a detailed report for a specific company
generate_company_report <- function(data, cid, export_csv = FALSE) {
  # Filter the main dataset to include only rows matching the given company ID
  sub <- data %>% filter(company_id == cid)
  # Create a list containing various summary statistics for the company
  report <- list(
    company      = cid,
    n_employees  = nrow(sub),
    # Calculate average salary rounded to the nearest whole number
    avg_salary   = round(mean(sub$salary), 0),
    # Calculate average KPI score rounded to 2 decimal places
    avg_kpi      = round(mean(sub$KPI_score), 2),
    # Calculate average performance score rounded to 2 decimal places
    avg_perf     = round(mean(sub$performance_score), 2),
    # Calculate the percentage of top performers in the company
    top_perf_pct = round(mean(sub$top_performer == "Yes") * 100, 1),
    # Create a frequency table of KPI tiers (e.g., Platinum, Gold, etc.)
    kpi_tiers    = table(sub$kpi_tier),
    # Create a sub-summary grouped by department
    dept_summary = sub %>%
      group_by(department) %>%
      summarise(Avg_KPI = round(mean(KPI_score),2), Avg_Salary = round(mean(salary),0),
                Count = n(), .groups = "drop") %>%
      # Sort the department summary by the highest average KPI score
      arrange(desc(Avg_KPI)))
  # If export_csv is TRUE, save the filtered company data to a physical CSV file
  if (export_csv) { write.csv(sub, file = paste0(cid, "_report.csv"), row.names = FALSE) }
  # Return the generated list object
  return(report)}

# Identify all unique company IDs present in the dataset
company_ids <- unique(kpi_data$company_id)
# Initialize an empty list to store multiple company reports
all_reports <- list()
# Loop through each unique company ID to generate its individual report
for (cid in company_ids) {
  # Call the report function and store the result in the list using the company ID as the key
  all_reports[[cid]] <- generate_company_report(kpi_data, cid, export_csv = TRUE)}

# Initialize an empty data frame to consolidate high-level report data
report_summary <- data.frame()
# Loop through the generated reports to build a summary table
for (cid in company_ids) {
  # Extract the report object for the current company ID
  r <- all_reports[[cid]]
  # Append a new row to the summary data frame with formatted values
  report_summary <- rbind(report_summary, data.frame(
    Company           = r$company,
    Employees         = r$n_employees,
    # Format salary with commas as thousands separators (e.g., 10,000)
    Avg_Salary        = formatC(r$avg_salary, format="d", big.mark=","),
    Avg_KPI           = r$avg_kpi,
    Avg_Performance   = r$avg_perf,
    # Append a percentage sign to the top performer metric
    Top_Performer_Pct = paste0(r$top_perf_pct, "%")
  ))}

# Define a function to render the summary data frame into a PDF document
render_summary_to_pdf <- function(df) {
  # Define the filename for the temporary RMarkdown file
  temp_rmd <- "temp_summary.Rmd"
  
  # Generate the content of the temporary RMarkdown file with YAML header and code chunks
  writeLines(c(
    "---",
    "title: 'Executive Summary Report'",
    "author: 'Wulan Gustika Antasya Tumanggor'",
    "output: pdf_document",
    "params:",                
    "  data: !r data.frame()", # Define a parameter to accept a data frame from the main environment
    "---",
    "",
    "```{r, echo=FALSE}",
    "# Use the data passed through params to create a formatted table",
    "knitr::kable(params$data, caption = 'Rekapitulasi Performa Perusahaan')",
    "```"), temp_rmd)
  
# Use the rmarkdown package to compile the temporary file into the final PDF
  rmarkdown::render(
    input       = temp_rmd,              # Source file
    params      = list(data = df),       # Pass the summary data frame into the Rmd parameters
    output_file = "Final_Summary_Report.pdf", # Name of the generated PDF file
    envir       = new.env(),             # Run in a clean environment to avoid variable conflicts
    quiet       = TRUE)                   # Suppress processing logs for a cleaner output
  
  # Clean up by removing the temporary RMarkdown file after the PDF is successfully created
  if (file.exists(temp_rmd)) {
    file.remove(temp_rmd)}}

# Execute the function to generate the final automated PDF report
render_summary_to_pdf(report_summary)