# ============================================================
# MAIN FUNCTION: compute_formula(x, formula)
# Wraps the entire logic for formula selection and calculation
# ============================================================

compute_formula <- function(x, formula) {

  # --- VALIDATION 1: Ensure x is numeric ---
  # If x is a character or factor, stop execution
  if (!is.numeric(x)) {
    stop("Error: Argument 'x' must be a numeric value.")
  }

  # --- VALIDATION 2: Ensure formula name is recognized ---
  # List of available formulas in this function
  valid_formulas <- c("linear", "quadratic", "cubic", "exponential")

  # Normalize input: convert to lowercase & remove extra spaces
  formula <- tolower(trimws(formula))

  # Check if the formula is in the valid list
  if (!(formula %in% valid_formulas)) {
    stop(paste("Unknown formula:", formula))
  }

  # --- CONDITIONAL LOGIC: Select and calculate formula ---
  # Using if-else to determine the formula based on input 'formula'

  if (formula == "linear") {
    # Linear formula: y = 2x + 1
    # Constant growth — increases by 2 for every 1 unit increase in x
    result <- 2 * x + 1

  } else if (formula == "quadratic") {
    # Quadratic formula: y = x^2 + 3x + 2
    # Growth accelerates as x increases (parabola)
    result <- x^2 + 3 * x + 2

  } else if (formula == "cubic") {
    # Cubic formula: y = x^3 - 2x^2 + x
    # Very rapid growth — dominant for large x
    result <- x^3 - 2 * x^2 + x

  } else if (formula == "exponential") {
    # Exponential formula: y = e^(0.3x)
    # Compounded growth — the fastest among all formulas
    result <- exp(0.3 * x)
  }

  # Return the calculation result
  return(result)
}

# ============================================================
# NESTED LOOPS: Iterate x and formulas
# ============================================================

# Helper function for calculation
compute_formula <- function(x, type) {
  type <- tolower(type)
  if (!is.numeric(x)) stop("x must be numeric")
  valid <- c("linear", "quadratic", "cubic", "exponential")
  if (!(type %in% valid)) stop(paste("Unknown formula:", type))
  
  switch(type,
    "linear"      = 2 * x + 1,
    "quadratic"   = x^2 + 3*x + 2,
    "cubic"       = x^3 - 2*x^2 + x - 1,
    "exponential" = 2^x
  )
}

# Define inputs
x_values <- 1:20
formulas <- c("linear", "quadratic", "cubic", "exponential")

# Initialize results dataframe
results <- data.frame(
  x       = integer(0),
  formula = character(0),
  y       = numeric(0)
)

# --- Nested Loop Execution ---
for (x_val in x_values) {          # Loop through x values
  for (frm in formulas) {          # Loop through formulas
    y_val <- compute_formula(x_val, frm)
    results <- rbind(
      results,
      data.frame(x = x_val, formula = frm, y = y_val)
    )
  }
}

# ============================================================
# OUTPUT: Wide format table
# ============================================================
library(tidyr)
library(knitr)

# Pivot data to wide format
results_wide <- pivot_wider(
  results,
  names_from  = formula,
  values_from = y
)

# Set clean column names
colnames(results_wide) <- c("x", "Linear", "Quadratic", "Cubic", "Exponential")

# Render table
kable(results_wide, format = "simple", align = "r",
      caption = "Comparison of y Values for Each Formula")

# ============================================================
# VALIDATION TEST: Ensuring the function handles incorrect input
# ============================================================

cat(
  # Test 1: Unknown formula
  tryCatch(compute_formula(5, "logarithmic"), error = function(e) e$message),
  
  # Test 2: x is not numeric
  tryCatch(compute_formula("ten", "linear"), error = function(e) e$message),
  
  # Test 3: Capitalized input (case-insensitive)
  compute_formula(5, "LINEAR"),
  
  # Test 4: x as a vector (vectorized)
  compute_formula(c(1, 5, 10), "quadratic"),
  
  sep = "\n"
)

# Initial setup to ensure consistent simulation results
set.seed(42)

simulate_sales <- function(n_salesperson, days) {

  # NESTED FUNCTION 1: Calculating daily accumulation (Loop)
  calc_cumulative <- function(sales_vec) {
    cum_total <- 0
    result    <- numeric(length(sales_vec))
    for (i in seq_along(sales_vec)) {
      cum_total  <- cum_total + sales_vec[i]
      result[i]  <- cum_total
    }
    return(result)
  }

  # NESTED FUNCTION 2: Discount logic (Conditional Logic)
  get_discount <- function(amount) {
    if      (amount >= 900) return(0.20)  # 20% Discount
    else if (amount >= 600) return(0.15)  # 15% Discount
    else if (amount >= 300) return(0.10)  # 10% Discount
    else                    return(0.05)  # 5% Discount
  }

  all_data <- data.frame()

  # OUTER LOOP: Iteration per salesperson
  for (sp in 1:n_salesperson) {
    sales_vec  <- numeric(days)
    disc_vec   <- numeric(days)

    # INNER LOOP: Daily iteration
    for (d in 1:days) {
      amt          <- round(runif(1, min = 100, max = 1000), 2)
      sales_vec[d] <- amt
      disc_vec[d]  <- get_discount(amt)
    }

    cum_vec <- calc_cumulative(sales_vec)

    # Storing results into a Data Frame
    sp_df <- data.frame(
      sales_id      = paste0("SP", sp),
      day           = 1:days,
      sales_amount  = sales_vec,
      discount_rate = disc_vec,
      cumulative    = cum_vec
    )
    all_data <- rbind(all_data, sp_df)
  }
  return(all_data)
}

# Main function: accepts a vector, returns a category vector
categorize_performance <- function(sales_vec) {
  # NESTED FUNCTION: Category logic for a single value (Conditional Logic)
  get_category <- function(val) {
    if      (val >= 900) return("Excellent")
    else if (val >= 700) return("Very Good")
    else if (val >= 500) return("Good")
    else if (val >= 300) return("Average")
    else                 return("Poor")
  }
  
  categories <- character(length(sales_vec))
  
  # LOOP: Iteration through each element of the sales vector
  for (i in seq_along(sales_vec)) {
    categories[i] <- get_category(sales_vec[i])
  }
  
  return(categories)
}

# Data df is already available from Task 2 — simply apply the categorization function
df$performance <- categorize_performance(df$sales_amount)
head(df)

generate_company_data <- function(n_company, n_employees) {
  departments <- c("HR", "Finance", "Engineering", "Marketing", "Operations")
  all_data <- list()

  for (comp in 1:n_company) {
    company_id <- paste0("Company_", LETTERS[comp])
    company_records <- list()

    for (emp in 1:n_employees) {
      employee_id       <- paste0(company_id, "_EMP", sprintf("%03d", emp))
      salary            <- round(runif(1, min = 3000, max = 15000), 2)
      department        <- sample(departments, 1)
      performance_score <- round(runif(1, min = 50, max = 100), 1)
      KPI_score         <- round(runif(1, min = 40, max = 100), 1)

      top_performer <- ifelse(KPI_score > 90, "Yes", "No")

      company_records[[emp]] <- data.frame(
        company_id        = company_id,
        employee_id       = employee_id,
        salary            = salary,
        department        = department,
        performance_score = performance_score,
        KPI_score         = KPI_score,
        top_performer     = top_performer,
        stringsAsFactors  = FALSE
      )
    }
    all_data[[comp]] <- do.call(rbind, company_records)
  }

  final_df <- do.call(rbind, all_data)
  rownames(final_df) <- NULL
  return(final_df)
}

# Generate 5 companies x 100 employees = 500 rows total
employee_data <- generate_company_data(n_company = 5, n_employees = 100)

monte_carlo_pi <- function(n_points) {
  
  # --- STEP 1: Generate Points ---
  set.seed(42)
  x <- runif(n_points, min = -1, max = 1)
  y <- runif(n_points, min = -1, max = 1)
  
  # --- STEP 2: Geometric Logic ---
  distance_sq <- x^2 + y^2
  inside_circle <- distance_sq <= 1
  
  # --- STEP 3: Pi Estimation ---
  pi_estimate <- 4 * sum(inside_circle) / n_points
  
  # --- STEP 4: Convergence Loop ---
  cat("=== π Convergence Over Iterations ===\n")
  checkpoints <- c(100, 500, 1000, 5000, n_points)
  for (n in checkpoints) {
    if (n <= n_points) {
      in_circle_n <- sum(x[1:n]^2 + y[1:n]^2 <= 1)
      pi_n        <- 4 * in_circle_n / n
      error_n     <- abs(pi_n - pi)
      cat(sprintf("  n = %6d | Estimate = %.6f | Error = %.6f\n", n, pi_n, error_n))
    }
  }
  
  # --- STEP 5: Probability Analysis ---
  in_subsquare     <- (x >= 0 & x <= 0.5) & (y >= 0 & y <= 0.5)
  prob_empirical   <- sum(in_subsquare) / n_points
  prob_theoretical <- (0.5 * 0.5) / (2 * 2)
  cat("\n=== Sub-square Probability [0, 0.5] ===\n")
  cat(sprintf("  Theoretical: %.6f | Empirical: %.6f\n", prob_theoretical, prob_empirical))
  
  # --- STEP 6: Build Plotly Objects ---
  plot_n       <- min(n_points, 3000)
  point_colors <- ifelse(inside_circle[1:plot_n], "#2196F3", "#F44336")
  point_labels <- ifelse(inside_circle[1:plot_n], "Inside Circle", "Outside Circle")
  
  theta    <- seq(0, 2 * pi, length.out = 500)
  circle_x <- cos(theta)
  circle_y <- sin(theta)
  
  p1 <- plot_ly() %>%
    add_trace(
      x = x[1:plot_n], y = y[1:plot_n],
      type = "scatter", mode = "markers",
      marker = list(color = point_colors, size = 3, opacity = 0.7),
      text = paste0(point_labels,
                    "<br>x = ", round(x[1:plot_n], 4),
                    "<br>y = ", round(y[1:plot_n], 4)),
      hoverinfo = "text",
      name = "Sample Points"
    ) %>%
    add_trace(
      x = circle_x, y = circle_y,
      type = "scatter", mode = "lines",
      line = list(color = "black", width = 2),
      hoverinfo = "none",
      name = "Unit Circle"
    ) %>%
    add_trace(
      x = c(0, 0.5, 0.5, 0, 0),
      y = c(0, 0, 0.5, 0.5, 0),
      type = "scatter", mode = "lines",
      line = list(color = "#FF9800", width = 2, dash = "dash"),
      hoverinfo = "none",
      name = "Sub-square [0–0.5]"
    ) %>%
    layout(
      title  = list(text = paste0("<b>Spatial Distribution</b> (n = ", n_points, ")"),
                    font = list(size = 14)),
      xaxis  = list(title = "X", range = c(-1.1, 1.1), scaleanchor = "y"),
      yaxis  = list(title = "Y", range = c(-1.1, 1.1)),
      legend = list(orientation = "h", y = -0.15),
      hovermode = "closest"
    )
  
  iter_seq     <- round(seq(100, n_points, length.out = 200))
  pi_estimates <- numeric(length(iter_seq))
  for (i in seq_along(iter_seq)) {
    n_i            <- iter_seq[i]
    in_c_i         <- sum(x[1:n_i]^2 + y[1:n_i]^2 <= 1)
    pi_estimates[i] <- 4 * in_c_i / n_i
  }
  errors <- abs(pi_estimates - pi)
  
  p2 <- plot_ly() %>%
    add_trace(
      x = iter_seq, y = pi_estimates,
      type = "scatter", mode = "lines",
      line = list(color = "#3F51B5", width = 1.5),
      text = paste0("n = ", iter_seq,
                    "<br>π̂ = ", round(pi_estimates, 6),
                    "<br>Error = ", round(errors, 6)),
      hoverinfo = "text",
      name = "Estimated π"
    ) %>%
    add_trace(
      x = c(min(iter_seq), max(iter_seq)),
      y = c(pi, pi),
      type = "scatter", mode = "lines",
      line = list(color = "#E53935", width = 2, dash = "dash"),
      hoverinfo = "none",
      name = paste0("True π = ", round(pi, 6))
    ) %>%
    layout(
      title     = list(text = "<b>Stability Trend of π</b>", font = list(size = 14)),
      xaxis     = list(title = "Sample Size (n)"),
      yaxis     = list(title = "Estimated π", range = c(pi - 0.3, pi + 0.3)),
      legend    = list(orientation = "h", y = -0.15),
      hovermode = "x unified"
    )
  
  invisible(list(
    pi_estimate    = pi_estimate,
    prob_empirical = prob_empirical,
    plot_spatial   = p1,        
    plot_converge  = p2
  ))
}

# FUNCTION 1: Min-Max Normalization [0, 1]
normalize_columns <- function(df) {
  non_num <- df[, !sapply(df, is.numeric), drop = FALSE]
  num_df  <- df[,  sapply(df, is.numeric), drop = FALSE]
  for (col in names(num_df)) {
    x             <- num_df[[col]]
    num_df[[col]] <- (x - min(x)) / (max(x) - min(x))
  }
  cbind(non_num, num_df)
}

# FUNCTION 2: Z-Score Standardization
z_score <- function(df) {
  non_num <- df[, !sapply(df, is.numeric), drop = FALSE]
  num_df  <- df[,  sapply(df, is.numeric), drop = FALSE]
  for (col in names(num_df)) {
    x             <- num_df[[col]]
    num_df[[col]] <- (x - mean(x)) / sd(x)
  }
  cbind(non_num, num_df)
}

# Apply functions
df_norm   <- normalize_columns(df)
df_zscore <- z_score(df)

# Build output tables
norm_summary <- as.data.frame(t(round(as.numeric(summary(df_norm$salary)), 6)))
colnames(norm_summary) <- c("Min", "Q1", "Median", "Mean", "Q3", "Max")

zscore_summary <- as.data.frame(t(round(as.numeric(summary(df_zscore$salary)), 6)))
colnames(zscore_summary) <- c("Min", "Q1", "Median", "Mean", "Q3", "Max")

# OUTPUT
knitr::kable(norm_summary, format = "simple", align = "c",
             caption = "Salary Statistics After Normalization")

knitr::kable(zscore_summary, format = "simple", align = "c",
             caption = "Salary Statistics After Z-Score")

# FUNCTION 3: create_features(df)
create_features <- function(df) {
  df <- df |>
    mutate(
      # Feature 1: Performance category
      performance_category = case_when(
        performance >= 8  ~ "Excellent",
        performance >= 6  ~ "Good",
        performance >= 4  ~ "Average",
        TRUE               ~ "Poor"
      ),

      # Feature 2: Salary bracket
      salary_bracket = case_when(
        salary >= 80000  ~ "High",
        salary >= 50000  ~ "Mid",
        salary >= 30000  ~ "Low",
        TRUE             ~ "Very Low"
      ),

      # Feature 3: Seniority flag
      is_senior = ifelse(experience >= 10, "Senior", "Junior"),

      # Feature 4: Age group
      age_group = cut(age,
                      breaks = c(20, 30, 40, 50, Inf),
                      labels = c("20s", "30s", "40s", "50s+"),
                      right  = FALSE)
    )
  return(df)
}

# Apply function
df_feat <- create_features(df)

# Build output tables
perf_df <- as.data.frame(table(df_feat$performance_category))
colnames(perf_df) <- c("Category", "Count")

salary_df <- as.data.frame(table(df_feat$salary_bracket))
colnames(salary_df) <- c("Bracket", "Count")

# OUTPUT
knitr::kable(perf_df, format = "simple", align = "c",
             caption = "Performance Category Distribution")

knitr::kable(salary_df, format = "simple", align = "c",
             caption = "Salary Bracket Distribution")

library(dplyr)
library(plotly)

# Set seed for reproducibility
set.seed(42)

# Function to generate simulated multi-company data
generate_company_data <- function(n_company, n_employees) {
  departments <- c("HR", "Finance", "Engineering", "Marketing", "Operations")
  all_data    <- list()
  
  for (comp in 1:n_company) {
    company_id      <- paste0("Company_", LETTERS[comp])
    company_records <- list()
    
    for (emp in 1:n_employees) {
      employee_id       <- paste0(company_id, "_EMP", sprintf("%03d", emp))
      salary            <- round(runif(1, min = 3000, max = 15000), 2)
      department        <- sample(departments, 1)
      performance_score <- round(runif(1, min = 50, max = 100), 1)
      KPI_score         <- round(runif(1, min = 40, max = 100), 1)
      top_performer     <- ifelse(KPI_score > 90, "Yes", "No")
      
      company_records[[emp]] <- data.frame(
        company_id        = company_id,
        employee_id       = employee_id,
        salary            = salary,
        department        = department,
        performance_score = performance_score,
        KPI_score         = KPI_score,
        top_performer     = top_performer,
        stringsAsFactors  = FALSE
      )
    }
    all_data[[comp]] <- do.call(rbind, company_records)
  }
  
  final_df           <- do.call(rbind, all_data)
  rownames(final_df) <- NULL
  return(final_df)
}

# Execute data generation
employee_data <- generate_company_data(n_company = 5, n_employees = 150)

# Initialize character vector for tiers
kpi_tier <- character(nrow(employee_data))

# Loop through each row to determine the tier
for (i in 1:nrow(employee_data)) {
  score <- employee_data$KPI_score[i]
  
  if (score > 90) {
    kpi_tier[i] <- "Elite"
  } else if (score >= 75) {
    kpi_tier[i] <- "High Performer"
  } else if (score >= 60) {
    kpi_tier[i] <- "Average"
  } else {
    kpi_tier[i] <- "Needs Improvement"
  }
}

# Assign the new column to the main dataframe
employee_data$kpi_tier <- kpi_tier

# Company-level summary
company_summary <- employee_data %>%
  group_by(company_id) %>%
  summarise(
    avg_salary      = round(mean(salary), 2),
    avg_KPI         = round(mean(KPI_score), 2),
    avg_performance = round(mean(performance_score), 2),
    top_performers  = sum(top_performer == "Yes"),
    elite_count     = sum(kpi_tier == "Elite"),
    total_employees = n(),
    .groups = "drop"
  )

# Department-level analysis
dept_summary <- employee_data %>%
  group_by(department) %>%
  summarise(
    avg_salary      = round(mean(salary), 2),
    avg_KPI         = round(mean(KPI_score), 2),
    total_employees = n(),
    .groups = "drop"
  ) %>%
  arrange(desc(avg_KPI))

library(dplyr)
library(plotly)
library(htmltools)

set.seed(42)

generate_company_data <- function(n_company, n_employees) {
  departments <- c("HR", "Finance", "Engineering", "Marketing", "Operations")
  all_data    <- list()
  
  for (comp in 1:n_company) {
    company_id      <- paste0("Company_", LETTERS[comp])
    company_records <- list()
    
    for (emp in 1:n_employees) {
      employee_id       <- paste0(company_id, "_EMP", sprintf("%03d", emp))
      salary            <- round(runif(1, min = 3000, max = 15000), 2)
      department        <- sample(departments, 1)
      performance_score <- round(runif(1, min = 50, max = 100), 1)
      KPI_score         <- round(runif(1, min = 40, max = 100), 1)
      top_performer     <- ifelse(KPI_score > 90, "Yes", "No")
      
      company_records[[emp]] <- data.frame(
        company_id        = company_id,
        employee_id       = employee_id,
        salary            = salary,
        department        = department,
        performance_score = performance_score,
        KPI_score         = KPI_score,
        top_performer     = top_performer,
        stringsAsFactors  = FALSE
      )
    }
    all_data[[comp]] <- do.call(rbind, company_records)
  }
  
  final_df           <- do.call(rbind, all_data)
  rownames(final_df) <- NULL
  return(final_df)
}

employee_data <- generate_company_data(n_company = 5, n_employees = 150)


employee_data$kpi_tier <- as.character(cut(employee_data$KPI_score,
                             breaks = c(0, 60, 75, 90, 100),
                             labels = c("Needs Improvement", "Average", "High Performer", "Elite"),
                             include.lowest = TRUE))

generate_summary_stats <- function(df_company) {
  list(
    total_employees = nrow(df_company),
    avg_salary      = round(mean(df_company$salary), 2),
    max_salary      = round(max(df_company$salary), 2),
    min_salary      = round(min(df_company$salary), 2),
    avg_KPI         = round(mean(df_company$KPI_score), 2),
    avg_performance = round(mean(df_company$performance_score), 2),
    top_performers  = sum(df_company$top_performer == "Yes"),
    elite_count     = sum(df_company$kpi_tier == "Elite"),
    hi_count        = sum(df_company$kpi_tier == "High Performer"),
    avg_count       = sum(df_company$kpi_tier == "Average"),
    low_count       = sum(df_company$kpi_tier == "Needs Improvement")
  )
}

export_csv <- function(df_company, comp_name, output_dir = ".") {
  file_name <- file.path(output_dir, paste0("Data_", comp_name, ".csv"))
  write.csv(df_company, file_name, row.names = FALSE)
  message("CSV exported : ", file_name)
  invisible(file_name)
}