# FORMULA DEFINITIONS 

calc_linear      <- function(x) 2 * x + 5
calc_quadratic   <- function(x) x^2 - 4 * x + 4
calc_cubic       <- function(x) 0.1 * x^3 - 2 * x^2 + x
calc_exponential <- function(x) exp(0.3 * x)

# Helper function to map text input to the appropriate function
get_formula_func <- function(name) {
  switch(name,
         "linear"      = calc_linear,
         "quadratic"   = calc_quadratic,
         "cubic"       = calc_cubic,
         "exponential" = calc_exponential,
         NULL) # Returns NULL if no match is found
}

# DATA PROCESSING & LOOPING

compute_data <- function(x_range, formulas) {
  results_list <- list()
  
  for (form_name in formulas) {
    func <- get_formula_func(form_name)
    
    if (is.null(func)) {
      message(paste("Warning: Formula '", form_name, "' is unrecognized."))
      next
    }
    
    # Calculate y-values for the entire x_range (Vectorized)
    y_values <- func(x_range)
    
    # Organize into a temporary list
    results_list[[form_name]] <- data.frame(
      x = x_range, 
      y = y_values, 
      formula = form_name
    )
  }
  
  # Combine all lists into a single dataframe
  final_df <- do.call(rbind, results_list)
  return(final_df)
}

# PROCESSING EXECUTION
x_input        <- 1:50  # Expanding the range for clearer visualization
selected_types <- c("linear", "quadratic", "cubic", "exponential", "typo_test")
result_data    <- compute_data(x_input, selected_types)

datatable(
  result_data, 
  options = list(
    pageLength = 10,            # Show 10 rows initially
    lengthMenu = c(10, 25, 50),  # Options for user to change row count
    order = list(list(2, 'asc')) # Sort by the 'formula' column
  ),
  caption = "Calculated Results Data"
)

plot_formulas_log <- function(df) {
  # Validate for empty data
  if (is.null(df) || nrow(df) == 0) {
    message("No valid data available to plot.")
    return(NULL)
  }
  
  ggplot(df, aes(x = x, y = y, color = formula)) +
    # Make lines slightly thinner to avoid overlap in log scale
    geom_line(linewidth = 1, alpha = 0.9) + 
    
    # --- KEY FOR CLARITY: Transform Y Scale to Logarithmic ---
    # trans = "log10" makes the distance between orders of magnitude (1, 10, 100, 1000) equal
    # labels = label_comma() converts scientific notation (1e+06) into commas (1,000,000)
    scale_y_log10(labels = label_comma(), 
                  breaks = trans_breaks("log10", function(x) 10^x)) +
    
    # Enhancing color palette
    scale_color_viridis_d(option = "turbo", name = "Formula Type") +
    
    labs(
      title = "Formula Comparison Chart (Logarithmic Scale)",
      subtitle = "Enables comparison between small vs. extremely large values",
      x = "X Axis (Input)", 
      y = "Y Axis (Output - Log Scale)"
    ) +
    theme_minimal() +
    theme(
      legend.position = "bottom",
      plot.title = element_text(face = "bold"),
      # Adding minor grid lines to assist in reading the log scale
      panel.grid.minor.y = element_line(color = "grey95") 
    )
}

# DISPLAY PLOT
plot_formulas_log(result_data)

simulate_sales <- function(n_salespeople, days) {
  # Internal function to calculate cumulative values
  calculate_cumulative <- function(vec) { return(cumsum(vec)) }
  
  final_data <- data.frame()
  
  for (id in 1:n_salespeople) {
    sales_amount <- round(runif(days, 50, 500), 2)
    
    # Discount Logic: 20% if > 400, 10% if > 200
    discount_rate <- ifelse(sales_amount > 400, 0.2, 
                            ifelse(sales_amount > 200, 0.1, 0))
    
    # Combine data into a data frame
    temp_df <- data.frame(
      salesperson_id = paste("Salesperson", id),
      day = 1:days,
      sales_amount = sales_amount,
      discount_rate = paste0(discount_rate * 100, "%"),
      cumulative_sales = calculate_cumulative(sales_amount)
    )
    
    # Append to the final data frame
    final_data <- rbind(final_data, temp_df)
  }
  
  return(final_data)
}

# Execute function and store the results
sales_data <- simulate_sales(n_salespeople = 3, days = 5)

base_table <- sales_data %>%
  kbl(caption = "Daily Sales Simulation Report") %>%
  kable_styling(bootstrap_options = c("striped", "hover", "condensed"), 
                full_width = F)

colored_table <- base_table %>%
  row_spec(0, bold = T, color = "white", background = "#2C3E50") %>% # Dark Blue Header
  column_spec(3, bold = T, background = "#ECF0F1") %>%              # Sales Column
  column_spec(5, color = "#27AE60", bold = T)                       # Cumulative Column (Green)

final_table <- colored_table %>%
  pack_rows("Salesperson Group 1", 1, 5) %>%
  pack_rows("Salesperson Group 2", 6, 10) %>%
  pack_rows("Salesperson Group 3", 11, 15)

# Display table
final_table

ggplot(sales_data, aes(x = day, y = cumulative_sales, color = salesperson_id)) + 
  geom_line(linewidth = 1) + 
  geom_point(size = 2) + 
  theme_minimal() + 
  labs(
    title = "Cumulative Sales Trend",
    x = "Day",
    y = "Total Sales",
    color = "Salesperson ID"
  )

# 0. Setup Sample Data (Required to run the code)
sales_data <- data.frame(
  sales_amount = c(450, 320, 250, 150, 50, 410, 380, 120)
)

# 1. Define the Function
categorize_performance <- function(sales_vector) {
  categories <- character(length(sales_vector))
  
  for (i in 1:length(sales_vector)) {
    val <- sales_vector[i]
    if (val >= 400) { 
      categories[i] <- "Excellent" 
    } else if (val >= 300) { 
      categories[i] <- "Very Good" 
    } else if (val >= 200) { 
      categories[i] <- "Good" 
    } else if (val >= 100) { 
      categories[i] <- "Average" 
    } else { 
      categories[i] <- "Poor" 
    }
  }
  return(categories)
}

# 2. Execution (The variable name here must match the one used in the next step)
# I have renamed this to 'performance_results'
performance_results <- categorize_performance(sales_data$sales_amount)

# 3. Create a Frequency Table
# Now 'performance_results' is recognized because it was defined above
counts <- table(performance_results)

# 4. Calculate Percentages
percent <- round(prop.table(counts) * 100, 1)

# 5. Combine into a Summary Table
summary_table <- data.frame(
  Category = names(counts),
  Count = as.vector(counts),
  Percentage = paste0(as.vector(percent), "%")
)

# Display result
print(summary_table)

# Define the number of companies and employees
n_company <- 3
n_employees <- 20
departments <- c("Sales", "IT", "HR", "Marketing", "Finance")

# Prepare an empty data container
all_data <- data.frame()

# Outer Loop: For each Company
for (c in 1:n_company) {
  company_id <- paste0("COMP_", c)
  
  # Inner Loop: For each Employee within that company
  for (e in 1:n_employees) {
    employee_id <- paste0("EMP_", c, "_", e)
    salary <- round(runif(1, 4000, 15000), 2)
    department <- sample(departments, 1)
    performance_score <- round(runif(1, 50, 100), 1)
    KPI_score <- round(runif(1, 50, 100), 1)
    
    # Conditional Logic: Determine Top Performer
    is_top_performer <- ifelse(KPI_score > 90, "Yes", "No")
    
    # Combine temporary data into the master table
    temp_df <- data.frame(company_id, employee_id, salary, department, 
                          performance_score, KPI_score, is_top_performer)
    all_data <- rbind(all_data, temp_df)
  }
}

# Display the first 6 rows of the generated data
head(all_data)

# Create a summary table per company
summary_table <- all_data %>%
  group_by(company_id) %>%
  summarise(
    avg_salary = mean(salary),
    avg_performance = mean(performance_score),
    max_KPI = max(KPI_score)
  )

# Print the summary to the console
print(summary_table)

# 1. Create a Bar Chart for Average Salary per Company
salary_plot <- ggplot(summary_table, aes(x = company_id, y = avg_salary, fill = company_id)) +
  geom_bar(stat = "identity", color = "black", width = 0.7) +
  geom_text(aes(label = round(avg_salary, 0)), vjust = -0.5) + # Add data labels above bars
  theme_minimal() +
  scale_fill_brewer(palette = "Set2") + # Use a professional color palette
  labs(
    title = "Comparison of Average Salary Across Companies",
    subtitle = "Based on simulated data for 60 employees",
    x = "Company ID",
    y = "Average Salary (USD)",
    fill = "Company"
  )

# 2. Display the plot
print(salary_plot)

# Define the number of iterations (points)
n_points <- 2000

# Initialize counters
points_inside_circle <- 0
points_in_subsquare <- 0

# Prepare empty vectors to store coordinates (for efficiency)
x_vals <- numeric(n_points)
y_vals <- numeric(n_points)
status <- character(n_points)

set.seed(123) # Optional: ensures results are consistent every time you run it

for (i in 1:n_points) {
  # Generate random x and y coordinates between -1 and 1
  x <- runif(1, min = -1, max = 1)
  y <- runif(1, min = -1, max = 1)
  
  x_vals[i] <- x
  y_vals[i] <- y
  
  # Check if the point is inside the circle using the Pythagorean formula: x^2 + y^2 <= r^2
  if (x^2 + y^2 <= 1) {
    points_inside_circle <- points_inside_circle + 1
    status[i] <- "Inside Circle"
  } else {
    status[i] <- "Outside Circle"
  }
  
  # Sub-square analysis (Quadrant 1, range 0 to 0.5)
  if (x >= 0 & x <= 0.5 & y >= 0 & y <= 0.5) {
    points_in_subsquare <- points_in_subsquare + 1
  }
}

# Formula for Pi estimation: (Area of Circle / Area of Square) * 4
pi_estimate <- 4 * (points_inside_circle / n_points)

# Probability of a point landing in the sub-square
subsquare_prob <- points_in_subsquare / n_points

# Create a summary table
summary_results <- data.frame(
  Metric = c("Total Points", "Pi Estimate", "Sub-square Prob"),
  Value = c(n_points, pi_estimate, subsquare_prob)
)

# Simply call the object to print it neatly
print(summary_results)

# Combine results into a dataframe
df_plot <- data.frame(x = x_vals, y = y_vals, Status = status)

# Create the Plot
ggplot(df_plot, aes(x = x, y = y, color = Status)) +
  geom_point(alpha = 0.5) +
  coord_fixed() + # Ensures the circle is a perfect circle, not an oval
  scale_color_manual(values = c("Inside Circle" = "blue", "Outside Circle" = "red")) +
  theme_minimal() +
  labs(
    title = paste("Monte Carlo Pi Visualization (n =", n_points, ")"),
    subtitle = paste("Pi Estimate =", round(pi_estimate, 4)),
    x = "X Coordinate",
    y = "Y Coordinate"
  )

# Setting a seed for reproducibility
set.seed(123)

# Creating simulation data
company_data <- data.frame(
  id = 1:10,
  salary = c(5000, 7000, 12000, 4500, 6000, 15000, 8000, 9000, 5500, 11000),
  performance_score = c(60, 75, 90, 55, 70, 95, 80, 85, 65, 88)
)

print(company_data)

# Min-Max Normalization: Rescales data to a range between 0 and 1
normalize_column <- function(x) {
  return((x - min(x)) / (max(x) - min(x)))
}

# Z-Score Standardization: Scales data so the Mean = 0 and SD = 1
z_score <- function(x) {
  return((x - mean(x)) / sd(x))
}

# Create a copy to keep the original data intact
df_transformed <- company_data 

# Target columns for transformation
cols_to_transform <- c("salary", "performance_score")

# Loop-based transformation
for (col in cols_to_transform) {
  # Create Normalization column
  df_transformed[[paste0(col, "_norm")]] <- normalize_column(df_transformed[[col]])
  # Create Z-score column
  df_transformed[[paste0(col, "_zscore")]] <- z_score(df_transformed[[col]])
}

# Feature Engineering: Categorizing salary into 3 levels
df_transformed$salary_bracket <- cut(df_transformed$salary, 
                                     breaks = 3, 
                                     labels = c("Low", "Medium", "High"))

# Displaying the transformed results
head(df_transformed)

# Creating a simulation dataset
set.seed(123)
n_company <- 5
n_employees <- 50

large_df <- data.frame(
  employee_id = 1:(n_company * n_employees),
  company_id = rep(paste0("Company_", 1:n_company), each = n_employees),
  department = sample(c("HR", "Tech", "Sales", "Finance"), n_company * n_employees, replace = TRUE),
  KPI_score = runif(n_company * n_employees, 50, 100),
  performance_score = runif(n_company * n_employees, 1, 10),
  salary = runif(n_company * n_employees, 5000, 15000)
)

# Output: Display the first 6 rows
head(large_df)

# Initialize a new column
large_df$KPI_tier <- character(nrow(large_df))

# Loop for categorization
for (i in 1:nrow(large_df)) {
  if (large_df$KPI_score[i] >= 85) {
    large_df$KPI_tier[i] <- "Tier 1 (Excellent)"
  } else if (large_df$KPI_score[i] >= 70) {
    large_df$KPI_tier[i] <- "Tier 2 (Good)"
  } else {
    large_df$KPI_tier[i] <- "Tier 3 (Needs Improvement)"
  }
}

# Output: Check category frequency
table(large_df$KPI_tier)

final_dashboard_data <- large_df

# Display final data summary
summary(final_dashboard_data)