# menghitung jenis formula menggunakan nested loop
compute_multiple_formulas <- function(x_values, formulas) {
  results <- data.frame()                # data kosong untuk menyimpan hasil
  for (f in formulas) {                  # loop untuk setiap jenis formula
    for (i in x_values) {                # loop untuk setiap nilai x
      
      # menentukan rumus berdasarkan jenis formula
      if (f == "linear") {
        y <- 3*i - 2
      } else if (f == "quadratic") {
        y <- i^2 - 4*i + 5
      } else if (f == "cubic") {
        y <- 0.05*i^3 - 3*i^2 + i + 5
      } else if (f == "exponential") {
        y <- 1.5^i
      }
      results <- rbind(results, data.frame(x = i, y = y, formula = f))  # simpan hasil
    }
  }
  return(results)
}

# fungsi untuk menghitung formula + validasi input
compute_formula_checked <- function(x_values, formulas) {
  valid_formulas <- c("linear", "quadratic", "cubic", "exponential")
  results <- data.frame()
  
  for (f in formulas) {                 # loop untuk setiap formula
    if (!(f %in% valid_formulas)) {     # cek apakah formula valid
      results <- rbind(results, data.frame(
        x = NA,
        y = NA,
        formula = f,
        status = "Invalid"              # ketentuan untuk invalid
      ))
      next                              # lanjut ke formula berikutnya
    }
    
    for (i in x_values) {               # jika valid dihitung
      if (f == "linear") {
        y <- 3*i - 2
      } else if (f == "quadratic") {
        y <- i^2 - 4*i + 5
      } else if (f == "cubic") {
        y <- 0.05*i^3 - 3*i^2 + i + 5
      } else if (f == "exponential") {
        y <- 1.5^i
      }
      
      results <- rbind(results, data.frame(   # simpan hasil + status valid
        x = i,
        y = y,
        formula = f,
        status = "Valid"
      ))
    }
  }
  return(results)
}

hitung_cumulative <- function(data) {   # menghitung cumulative sales per salesperson
  cumulative_manual <- function(x) {    # fungsi manual untuk cumulative
    total <- 0                    # inisialisasi total
    hasil <- c()                  # vector kosong
    
    for (i in x) {                # loop setiap nilai sales
      total <- total + i          # menambahkan nilai ke total
      hasil <- c(hasil, total)    # menyimpan hasil cumulative
    }
    return(hasil)
  }
  
  data$cumulative_sales <- ave(   # menerapkan fungsi cumulative ke setiap sales_id
    data$sales_amount, 
    data$sales_id, 
    FUN = cumulative_manual
  )
  return(data)   # mengembalikan data dengan kolom baru
}

# fungsi untuk generate data sales
generate_sales_data <- function(n_salesperson, days) {
  results <- data.frame()
  
  for (s in 1:n_salesperson) {              # loop tiap salesperson
    sales_id <- paste0("5225", s)           # membuat ID unik

    for (d in 1:days) {                     # loop tiap hari
      sales_amount <- sample(100:1500, 1)   # generate sales random
      
      # menentukan diskon berdasarkan jumlah sales
      if (sales_amount > 1000) {
        discount <- "20%"
      } else if (sales_amount > 500) {
        discount <- "10%"
      } else {
        discount <- "5%"
      }
      
      # simpan ke data frame
      results <- rbind(results, data.frame(
        sales_id = sales_id,
        day = d,
        sales_amount = sales_amount,
        discount_rate = discount
      ))
    }
  }
  
  return(results)
}

summary_sales <- sales_data %>%              # membuat ringkasan per salesperson
  group_by(sales_id) %>%                     # mengelompokkan berdasarkan sales_id
  summarise(
    total_sales = sum(sales_amount),         # menghitung total sales
    avg_sales = round(mean(sales_amount), 2) # menghitung rata-rata sales
  )

# fungsi untuk mengkategorikan performa berdasarkan sales
categorize_performance <- function(sales_vector) {
  categories <- c()  # simpan hasil
  
  # loop setiap nilai sales
  for (i in sales_vector) {
    
    if (i > 1200) {
      cat <- "Excellent"
    } else if (i > 900) {
      cat <- "Very Good"
    } else if (i > 600) {
      cat <- "Good"
    } else if (i > 300) {
      cat <- "Average"
    } else {
      cat <- "Poor"
    }
    categories <- c(categories, cat)
  }
  return(categories)
}

sales_vector <- sales_data$sales_amount              # ambil kolom sales task 2
performance <- categorize_performance(sales_vector)  # kategorisasi performance
sales_data$performance <- performance                # menambahkan hasil kategori ke dataset
summary_perf <- sales_data %>%                       # ringkasan jumlah & persentase tiap kategori
  group_by(performance) %>%                          # kelompokkan berdasarkan kategori
  summarise(count = n()) %>%                         # hitung jumlah data
  mutate(percentage = round((count / sum(count)) * 100, 2))  # hitung persentase

generate_company_data <- function(n_company, n_employees) {  # generate data perusahaan
  data <- data.frame()
  dept_list <- c("HR", "Finance", "IT", "Marketing")
  
  for (c in 1:n_company) {             # loop untuk setiap company
    company_id <- paste0("COMP", c)
    
    for (e in 1:n_employees) {         # loop untuk setiap karyawan
      employee_id <- paste0(company_id, "_EMP", e)
      salary <- sample(4000:15000, 1)       # salary random
      department <- sample(dept_list, 1)    # department random
      performance_score <- sample(65:98, 1) # performance score
      KPI_score <- round(rnorm(1, mean = 85, sd = 8)) # KPI variatif
      KPI_score <- max(min(KPI_score, 100), 70)  # batas 70–100
      
      # conditional
      if (KPI_score > 90) {
        status <- "Top Performer"
      } else {
        status <- "Regular"
      }
      data <- rbind(data, data.frame(
        company_id = company_id,
        employee_id = employee_id,
        salary = salary,
        department = department,
        performance_score = performance_score,
        KPI_score = KPI_score,
        status = status
      ))
    }
  }
  return(data)
}

company_data <- generate_company_data(4, 12)                # generate data
company_data <- company_data[sample(nrow(company_data)), ]  # acak data

summary_company <- company_data %>%        # membuat ringkasan per company
  group_by(company_id) %>%                 # mengelompokkan data berdasarkan company
  summarise(
    avg_salary = round(mean(salary), 2),   # menghitung rata-rata salary
    avg_performance = round(mean(performance_score), 2),  # menghitung rata-rata performance
    max_KPI = max(KPI_score)               # mengambil nilai KPI tertinggi
  )

# fungsi untuk simulasi monte carlo
monte_carlo_sim <- function(n_points) {
  data <- data.frame()
  for (i in 1:n_points) {           # loop untuk generate titik
    x <- runif(1)                   # random titik (0 - 1)
    y <- runif(1)
    
    if (x^2 + y^2 <= 1) {           # cek apakah masuk lingkaran
      posisi <- "Inside"
    } else {
      posisi <- "Outside"
    }
    
    if (x <= 0.5 && y <= 0.5) {     # cek apakah masuk sub-square
      square <- "Yes"
    } else {
      square <- "No"
    }

    data <- rbind(data, data.frame( # simpan ke data frame
      x = x,
      y = y,
      posisi = posisi,
      in_square = square
    ))
  }
  return(data)
}

n_points <- 3000                                  # jumlah titik percobaan dalam simulasi Monte Carlo
mc_data <- monte_carlo_sim(n_points)              # menghasilkan dataset posisi titik
inside_count <- sum(mc_data$posisi == "Inside")   # menghitung jumlah titik "Inside"
pi_estimate <- 4 * (inside_count / n_points)      # hitung rumus π dari rasio luas lingkaran

# menghitung jumlah titik yang berada di dalam square
square_count <- sum(mc_data$in_square == "Yes")   # menghitung jumlah "Yes"

# menghitung probabilitas titik jatuh ke dalam square
prob_square <- square_count / n_points   # jumlah dalam square dibagi total titik

normalize_df <- function(df, cols) {  # normalisasi (skala 0–1)
  
  for (col in cols) {                 # loop untuk setiap kolom numerik
    min_val <- min(df[[col]])         # mengambil nilai minimum
    max_val <- max(df[[col]])         # mengambil nilai maksimum
    
    # menghitung normalisasi dan membuat kolom baru dengan suffix "_norm"
    df[[paste0(col, "_norm")]] <- (df[[col]] - min_val) / (max_val - min_val)
  }
  
  return(df)   # mengembalikan data yang sudah dinormalisasi
}

zscore_df <- function(df, cols) {           # fungsi untuk menghitung z-score
  
  for (col in cols) {                       # loop untuk setiap kolom numerik
    mean_val <- mean(df[[col]])             # menghitung rata-rata
    sd_val <- sd(df[[col]])                 # menghitung standar deviasi
    df[[paste0(col, "_z")]] <- (df[[col]] - mean_val) / sd_val  # menghitung z-score dan membuat kolom baru dengan suffix "_z"
  }
  
  return(df)   # mengembalikan data yang sudah ditransformasi
}

# menggunakan data dari task sebelumnya
df <- company_data                                         # menyalin dataset agar tidak mengubah data asli
num_cols <- c("salary", "performance_score", "KPI_score")  # menentukan kolom numerik yang akan ditransformasi
df <- normalize_df(df, num_cols)                           # melakukan normalisasi (0–1) menggunakan fungsi yang sudah dibuat
df <- zscore_df(df, num_cols)                              # menghitung z-score untuk melihat deviasi dari rata-rata

# pembulatan hasil transformasi agar lebih rapi
for (col in c("salary_norm","performance_score_norm","KPI_score_norm",
              "salary_z","performance_score_z","KPI_score_z")) {
  
  df[[col]] <- round(df[[col]], 3)   # membulatkan hingga 3 desimal
}

# FEATURE ENGINEERING
# membuat kategori performance berdasarkan nilai performance_score
df$performance_category <- ifelse(df$performance_score > 85, "High",
                           ifelse(df$performance_score > 70, "Medium", "Low"))

# membuat kategori salary berdasarkan rentang gaji
df$salary_bracket <- ifelse(df$salary > 10000, "High",
                     ifelse(df$salary > 7000, "Medium", "Low"))

compare_table <- data.frame(       # membuat tabel perbandingan statistik before after
  Statistic = c("Min", "Q1", "Median", "Mean", "Q3", "Max"),  # jenis statistik deskriptif
  Before = as.numeric(summary(company_data$salary)),          # statistik salary before
  After = round(as.numeric(summary(df$salary_norm)), 4)       # statistik after 
)

datatable(                           # menampilkan tabel dengan format interaktif
  compare_table,
  rownames = FALSE,                  # menghilangkan index tabel
  options = list(pageLength = 6),    # jumlah baris yang ditampilkan
  class = "stripe hover"             # styling tabel
) %>%
  formatStyle(
    names(compare_table)             # memberi style ke seluruh kolom
  )

generate_company_data <- function() {   # fungsi untuk generate dataset multi-company
  emp_counts <- c(70, 50, 95, 65, 135, 110, 150)   # jumlah karyawan per company
  departments <- c("HR", "Finance", "IT", "Marketing", "Operations")  # daftar department
  data <- data.frame()   # menyiapkan data kosong
  
  for (c in 1:length(emp_counts)) {    # loop untuk setiap company
    company_id <- paste0("1626C", c)   # membuat ID company
    n_emp <- emp_counts[c]             # mengambil jumlah karyawan
    
    for (e in 1:n_emp) {               # loop setiap karyawan dalam company
      employee_id <- paste0(company_id, "_", sprintf("%03d", e))  # membuat ID employee
      salary <- sample(3000:15000, 1)             # generate salary random
      performance <- sample(60:100, 1)            # generate performance random
      KPI <- round(performance + rnorm(1, 0, 5))  # KPI berbasis performance + variasi normal
      KPI <- max(min(KPI, 100), 50)               # membatasi KPI antara 50–100
      dept <- sample(departments, 1)              # memilih department secara acak
      
      # menambahkan data ke dalam dataset
      data <- rbind(data, data.frame(
        employee_id = employee_id,
        company_id = company_id,
        salary = salary,
        performance_score = performance,
        KPI_score = KPI,
        department = dept
      ))
    }
  }
  
  data <- data[sample(nrow(data)), ]   # mengacak urutan data
  return(data)                         # mengembalikan dataset
}

summary_company <- company_data %>%        # membuat ringkasan data per company
  group_by(company_id) %>%                 # mengelompokkan data berdasarkan company
  summarise(
    avg_salary = round(mean(salary), 0),   # menghitung rata-rata salary
    avg_KPI = round(mean(KPI_score), 1),   # menghitung rata-rata KPI
    top_performers = sum(KPI_score > 90)   # menghitung jumlah karyawan dengan KPI > 90
  )

categorize_kpi <- function(df) {   # mengkategorikan KPI menjadi beberapa level
  tiers <- c()                     # menyiapkan vector kosong untuk menyimpan kategori
  
  for (i in df$KPI_score) {        # loop setiap nilai KPI
    if (i > 90) {
      tiers <- c(tiers, "High")    # KPI tinggi
    } else if (i > 75) {
      tiers <- c(tiers, "Medium")  # KPI sedang
    } else {
      tiers <- c(tiers, "Low")     # KPI rendah
    }
  }
  
  df$KPI_tier <- tiers   # menambahkan kolom kategori ke data
  return(df)             # mengembalikan data yang sudah ditambahkan kategori
}

company_data <- categorize_kpi(company_data)  # menerapkan fungsi ke dataset

top_perf <- company_data %>%   # mengambil data karyawan dengan KPI tinggi (top performers)
  filter(KPI_score > 90)       # menyaring karyawan dengan KPI di atas 90

# membuat ringkasan per company dan department
dept_analysis <- company_data %>% 
  group_by(company_id, department) %>%    # mengelompokkan data berdasarkan company & department
  summarise(
    avg_salary = round(mean(salary), 0),  # menghitung rata-rata salary
    count = n(),                          # menghitung jumlah karyawan
    .groups = "drop"                      # menghilangkan struktur grouping
  )
output_list <- list()                     # menyiapkan list untuk menyimpan output

for (comp in unique(dept_analysis$company_id)) {           # loop untuk setiap company
  title <- tags$h4(paste("Department Analysis -", comp))   # membuat judul per company
  table <- datatable(
    dept_analysis %>% filter(company_id == comp),          # filter data sesuai company
    rownames = FALSE,
    class = "stripe hover"                                 # styling tabel
  )
  output_list[[comp]] <- tagList(title, table, tags$br())  # menyimpan hasil ke dalam list
}

tagList(output_list)   # menampilkan output