Update app.R

app.R

@@ -1,58 +1,957 @@
 library(shiny)
-library(bslib)
+library(shinydashboard)
+library(shinyBS)
+library(DT)
 library(dplyr)
-library(ggplot2)
+library(readr)
+library(stringr)
 
-df <- readr::read_csv("penguins.csv")
-# Find subset of columns that are suitable for scatter plot
-df_num <- df |> select(where(is.numeric), -Year)
+# Define columns to remove if they exist
+columns_to_remove <- c(
+  "SpinAxis3dTransverseAngle", "SpinAxis3dLongitudinalAngle", "SpinAxis3dActiveSpinRate",
+  "SpinAxis3dSpinEfficiency", "SpinAxis3dTilt", "SpinAxis3dVectorX", "SpinAxis3dVectorY",
+  "SpinAxis3dVectorZ", "SpinAxis3dSeamOrientationRotationX", "SpinAxis3dSeamOrientationRotationY",
+  "SpinAxis3dSeamOrientationRotationZ", "SpinAxis3dSeamOrientationBallYAmb1",
+  "SpinAxis3dSeamOrientationBallAngleHorizontalAmb1", "SpinAxis3dSeamOrientationBallZAmb1",
+  "SpinAxis3dSeamOrientationBallAngleVerticalAmb2", "SpinAxis3dSeamOrientationBallZAmb2",
+  "SpinAxis3dSeamOrientationBallXAmb4", "SpinAxis3dSeamOrientationBallYAmb4",
+  "SpinAxis3dSeamOrientationBallAngleHorizontalAmb2", "SpinAxis3dSeamOrientationBallAngleVerticalAmb1",
+  "SpinAxis3dSeamOrientationBallXAmb1", "SpinAxis3dSeamOrientationBallYAmb2",
+  "SpinAxis3dSeamOrientationBallAngleHorizontalAmb4", "SpinAxis3dSeamOrientationBallAngleVerticalAmb4",
+  "SpinAxis3dSeamOrientationBallXAmb2", "SpinAxis3dSeamOrientationBallAngleVerticalAmb3",
+  "SpinAxis3dSeamOrientationBallAngleHorizontalAmb3", "SpinAxis3dSeamOrientationBallXAmb3",
+  "SpinAxis3dSeamOrientationBallYAmb3", "SpinAxis3dSeamOrientationBallZAmb3",
+  "SpinAxis3dSeamOrientationBallZAmb4", "BatSpeed", "GameDate", "HorizontalAttackAngle",
+  "Horizontal Attack Angle", "VerticalAttackAngle", "Vertical attack angle"
+)
+
+# Pitch colors for visualization (Coastal Carolina theme)
+pitch_colors <- c(
+  "Fastball" = '#FA8072',
+  "Four-Seam" = '#FA8072',
+  "Sinker" = "#fdae61",
+  "Slider" = "#A020F0",
+  "Sweeper" = "magenta",
+  "Curveball" = '#2c7bb6',
+  "ChangeUp" = '#90EE90',
+  "Splitter" = '#90EE32',
+  "Cutter" = "red",
+  "Knuckleball" = "#FFB4B4",
+  "Other" = "#D3D3D3"
+)
+
+# Function to process the uploaded data (only remove columns)
+process_baseball_data <- function(df) {
+  # Remove unwanted columns
+  columns_to_drop <- intersect(names(df), columns_to_remove)
+  if (length(columns_to_drop) > 0) {
+    df <- df %>% select(-all_of(columns_to_drop))
+  }
+  
+  # Remove duplicates only
+  df <- df %>% distinct()
+  
+  return(df)
+}
 
-ui <- page_sidebar(
-  theme = bs_theme(bootswatch = "minty"),
-  title = "Penguins explorer",
-  sidebar = sidebar(
-    varSelectInput("xvar", "X variable", df_num, selected = "Bill Length (mm)"),
-    varSelectInput("yvar", "Y variable", df_num, selected = "Bill Depth (mm)"),
-    checkboxGroupInput("species", "Filter by species",
-      choices = unique(df$Species), selected = unique(df$Species)
-    ),
-    hr(), # Add a horizontal rule
-    checkboxInput("by_species", "Show species", TRUE),
-    checkboxInput("show_margins", "Show marginal plots", TRUE),
-    checkboxInput("smooth", "Add smoother"),
+# UI
+ui <- fluidPage(
+  tags$head(
+    tags$style(HTML("
+    body, table, .gt_table {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto,
+        Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji',
+        'Segoe UI Symbol';
+    }
+    
+    /* Header styling */
+    .app-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      padding: 20px 40px;
+      background: #ffffff);
+      border-bottom: 3px solid darkcyan;
+      margin-bottom: 20px;
+    }
+    
+    .header-logo-left, .header-logo-right {
+      width: 120px;
+      height: auto;
+    }
+    
+    .header-logo-center {
+      max-width: 400px;
+      height: auto;
+    }
+    
+    @media (max-width: 768px) {
+      .app-header {
+        flex-direction: column;
+        padding: 15px 20px;
+      }
+      .header-logo-left, .header-logo-right {
+        width: 80px;
+      }
+      .header-logo-center {
+        max-width: 250px;
+        margin: 10px 0;
+      }
+    }
+    
+    /* Gradient pill tabs styling */
+    .nav-tabs {
+      border: none !important;
+      border-radius: 50px;
+      padding: 6px 12px;
+      margin: 20px auto 0;
+      max-width: 100%;
+      background: linear-gradient(135deg, #d4edeb 0%, #e8ddd0 50%, #d4edeb 100%);
+      box-shadow: 0 4px 16px rgba(0,139,139,.12), inset 0 2px 4px rgba(255,255,255,.6);
+      border: 1px solid rgba(0,139,139,.2);
+      position: relative;
+      overflow-x: auto;
+      -webkit-overflow-scrolling: touch;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      flex-wrap: wrap;
+      gap: 6px;
+    }
+    
+    .nav-tabs::-webkit-scrollbar {
+      height: 0;
+    }
+    
+    .nav-tabs::before {
+      content: '';
+      position: absolute;
+      inset: 0;
+      pointer-events: none;
+      border-radius: 50px;
+      background: linear-gradient(135deg, rgba(255,255,255,.4), transparent);
+    }
+    
+    .nav-tabs > li > a {
+      color: darkcyan !important;
+      border: none !important;
+      border-radius: 50px !important;
+      background: transparent !important;
+      font-weight: 700;
+      font-size: 14.5px;
+      padding: 10px 22px;
+      white-space: nowrap;
+      letter-spacing: 0.2px;
+      transition: all 0.2s ease;
+    }
+    
+    .nav-tabs > li > a:hover {
+      color: #006666 !important;
+      background: rgba(255,255,255,.5) !important;
+      transform: translateY(-1px);
+    }
+    
+    .nav-tabs > li.active > a,
+    .nav-tabs > li.active > a:focus,
+    .nav-tabs > li.active > a:hover {
+      background: linear-gradient(135deg, #008b8b 0%, #20b2aa 30%, #00ced1 50%, #20b2aa 70%, #008b8b 100%) !important;
+      color: #fff !important;
+      text-shadow: 0 1px 2px rgba(0,0,0,.2);
+      box-shadow: 0 4px 16px rgba(0,139,139,.4), inset 0 2px 8px rgba(255,255,255,.4), inset 0 -2px 6px rgba(0,0,0,.2);
+      border: 1px solid rgba(255,255,255,.3) !important;
+    }
+    
+    .nav-tabs > li > a:focus {
+      outline: 3px solid rgba(205,133,63,.6);
+      outline-offset: 2px;
+    }
+    
+    .tab-content {
+      background: linear-gradient(135deg, rgba(255,255,255,.95), rgba(248,249,250,.95));
+      border-radius: 20px;
+      padding: 25px;
+      margin-top: 14px;
+      box-shadow: 0 15px 40px rgba(0,139,139,.1);
+      backdrop-filter: blur(15px);
+      border: 1px solid rgba(0,139,139,.1);
+      position: relative;
+      overflow: hidden;
+    }
+    
+    .tab-content::before {
+      content: '';
+      position: absolute;
+      left: 0;
+      right: 0;
+      top: 0;
+      height: 4px;
+      background: linear-gradient(90deg, darkcyan, peru, darkcyan);
+      background-size: 200% 100%;
+      animation: shimmer 3s linear infinite;
+    }
+    
+    @keyframes shimmer {
+      0% { background-position: -200% 0; }
+      100% { background-position: 200% 0; }
+    }
+    
+    #name { 
+      font-size: 10px; 
+      font-weight: 500; 
+      text-align: right; 
+      margin-bottom: 8px;
+      color: #6C757D;
+      letter-spacing: 0.5px;
+    }
+    
+    h3 {
+      color: black;
+      font-weight: 600;
+      margin-top: 25px;
+      margin-bottom: 15px;
+      padding-bottom: 8px;
+      border-bottom: 2px solid #007BA7;
+    }
+    
+    h4 {
+      color: white;
+      font-weight: 500;
+      margin-top: 20px;
+      margin-bottom: 12px;
+    }
+    
+    h1 {
+      color: #007BA7;
+      font-weight: 700;
+      margin-bottom: 20px;
+      text-shadow: 1px 1px 2px rgba(0,0,0,0.1);
+    }
+    
+    label {
+      font-weight: 500;
+      color: peru;
+      margin-bottom: 5px;
+    }
+    
+    .plot-title {
+      text-align: center;
+      font-weight: 600;
+      color: #2C3E50;
+      margin-bottom: 10px;
+    }
+    
+    .dataTables_wrapper .dataTables_length,
+    .dataTables_wrapper .dataTables_filter,
+    .dataTables_wrapper .dataTables_info,
+    .dataTables_wrapper .dataTables_paginate {
+      color: #2C3E50;
+    }
+    
+    thead th {
+      background-color: #F8F9FA;
+      color: #2C3E50;
+      font-weight: 600;
+      text-align: center !important;
+      padding: 10px !important;
+    }
+    
+    .brand-teal { color: darkcyan; }
+    .brand-bronze { color: peru; }
+  "))
+  ),
+  
+  # Header with three logos
+  div(class = "app-header",
+      tags$img(src = "https://i.imgur.com/7vx5Ci8.png", class = "header-logo-left", alt = "Logo Left"),
+      tags$img(src = "https://i.imgur.com/c3zCSg6.png", class = "header-logo-center", alt = "Main Logo"),
+      tags$img(src = "https://i.imgur.com/VbrN5WV.png", class = "header-logo-right", alt = "Logo Right")
   ),
-  plotOutput("scatter")
+  
+  tabsetPanel(id = "main_tabs",
+              
+              # Upload & Process Tab
+              tabPanel(
+                "Upload & Process",
+                fluidRow(
+                  column(12,
+                         h3("Upload CSV File"),
+                         fileInput("file", "Choose CSV File", accept = c(".csv")),
+                         fluidRow(
+                           column(4,
+                                  checkboxInput("header", "Header", TRUE)
+                           ),
+                           column(4,
+                                  radioButtons("sep", "Separator",
+                                               choices = c(Comma = ",", Semicolon = ";", Tab = "\t"),
+                                               selected = ",", inline = TRUE)
+                           ),
+                           column(4,
+                                  radioButtons("quote", "Quote",
+                                               choices = c(None = "", "Double Quote" = '"', "Single Quote" = "'"),
+                                               selected = '"', inline = TRUE)
+                           )
+                         )
+                  )
+                ),
+                
+                fluidRow(
+                  column(8,
+                         h3("Columns to Remove"),
+                         p("Select which columns to remove from your dataset:"),
+                         checkboxGroupInput("columns_to_remove", "Remove These Columns:",
+                                            choices = columns_to_remove,
+                                            selected = columns_to_remove)
+                  ),
+                  column(4,
+                         h3("Quick Actions"),
+                         br(),
+                         actionButton("select_all_cols", "Select All", class = "btn-primary"),
+                         br(), br(),
+                         actionButton("deselect_all_cols", "Deselect All", class = "btn-default"),
+                         br(), br(),
+                         actionButton("select_spinaxis", "Select SpinAxis3d Columns", class = "btn-info"),
+                         br(), br(),
+                         actionButton("select_attack_angle", "Select Attack Angle Columns", class = "btn-info"),
+                         br(), br(),
+                         h4("Processing Summary"),
+                         verbatimTextOutput("process_summary")
+                  )
+                )
+              ),
+              
+              # Preview Data Tab
+              tabPanel(
+                "Preview Data",
+                fluidRow(
+                  column(12,
+                         h3("Data Preview"),
+                         DT::dataTableOutput("preview")
+                  )
+                )
+              ),
+              
+              # Pitch Movement Chart Tab
+              tabPanel(
+                "Pitch Movement Chart",
+                fluidRow(
+                  column(3,
+                         selectInput("pitcher_select", "Select Pitcher:", 
+                                     choices = NULL, selected = NULL)
+                  ),
+                  column(3,
+                         h4("Selection Mode:"),
+                         radioButtons("selection_mode", "",
+                                      choices = list("Single Click" = "single", "Drag Select" = "drag"),
+                                      selected = "single", inline = TRUE)
+                  ),
+                  column(6,
+                         conditionalPanel(
+                           condition = "input.selection_mode == 'drag'",
+                           h4("Bulk Edit:"),
+                           fluidRow(
+                             column(8,
+                                    selectInput("bulk_pitch_type", "Change all selected to:",
+                                                choices = c("Fastball", "Sinker", "Cutter", "Slider", 
+                                                            "Curveball", "ChangeUp", "Splitter", "Knuckleball", "Other"),
+                                                selected = "Fastball")
+                             ),
+                             column(4,
+                                    br(),
+                                    actionButton("apply_bulk_change", "Apply to Selected", class = "btn-success")
+                             )
+                           )
+                         )
+                  )
+                ),
+                
+                fluidRow(
+                  column(8,
+                         h3("Interactive Pitch Movement Analysis"),
+                         plotOutput("movement_plot", height = "600px", 
+                                    click = "plot_click",
+                                    brush = brushOpts(id = "plot_brush"),
+                                    hover = hoverOpts(id = "plot_hover", delay = 100)),
+                         
+                         h4("Instructions:"),
+                         p(strong("Single Click Mode:"), "Click on any point to edit one pitch type at a time via popup modal."),
+                         p(strong("Drag Select Mode:"), "Click and drag to select multiple points, then use the dropdown to change them all at once."),
+                         conditionalPanel(
+                           condition = "input.selection_mode == 'drag'",
+                           div(style = "background-color: #f0f8ff; padding: 10px; border-radius: 5px; margin: 10px 0; border-left: 4px solid darkcyan;",
+                               h4("Selected Points:", style = "margin-top: 0; color: darkcyan;"),
+                               textOutput("selection_info")
+                           )
+                         ),
+                         verbatimTextOutput("hover_info"),
+                         verbatimTextOutput("click_info")
+                  ),
+                  
+                  column(4,
+                         h3("Pitch Metrics Summary"),
+                         DT::dataTableOutput("movement_stats")
+                  )
+                )
+              ),
+              
+              # Download Tab
+              tabPanel(
+                "Download",
+                fluidRow(
+                  column(12,
+                         h3("Download Processed Data"),
+                         h4("Your processed data is ready for download!"),
+                         br(),
+                         downloadButton("downloadData", "Download CSV", class = "btn-success btn-lg"),
+                         br(), br(),
+                         h4("Data Summary:"),
+                         verbatimTextOutput("data_summary")
+                  )
+                )
+              )
+  ),
+  
+  # Modal for editing pitch type
+  bsModal("pitchEditModal", "Edit Pitch Type", "triggerModal", size = "medium",
+          div(style = "padding: 20px;",
+              h4("Selected Pitch Details:", style = "color: darkcyan;"),
+              verbatimTextOutput("selected_pitch_info"),
+              br(),
+              selectInput("modal_new_pitch_type", "Change Pitch Type To:",
+                          choices = c("Fastball", "Sinker", "Cutter", "Slider", 
+                                      "Curveball", "ChangeUp", "Splitter", "Knuckleball", "Other"),
+                          selected = "Fastball"),
+              br(),
+              actionButton("update_pitch", "Update Pitch Type", class = "btn-primary btn-lg"),
+              actionButton("cancel_edit", "Cancel", class = "btn-default")
+          )
+  )
 )
 
+# Server
 server <- function(input, output, session) {
-  subsetted <- reactive({
-    req(input$species)
-    df |> filter(Species %in% input$species)
+  
+  # Reactive values
+  processed_data <- reactiveVal(NULL)
+  plot_data <- reactiveVal(NULL)
+  selected_pitch <- reactiveVal(NULL)
+  selected_points <- reactiveVal(NULL)
+  
+  # Handle column selection buttons
+  observeEvent(input$select_all_cols, {
+    updateCheckboxGroupInput(session, "columns_to_remove", 
+                             selected = columns_to_remove)
   })
-
-  output$scatter <- renderPlot(
-    {
-      p <- ggplot(subsetted(), aes(!!input$xvar, !!input$yvar)) +
-        theme_light() +
-        list(
-          theme(legend.position = "bottom"),
-          if (input$by_species) aes(color = Species),
-          geom_point(),
-          if (input$smooth) geom_smooth()
-        )
-
-      if (input$show_margins) {
-        margin_type <- if (input$by_species) "density" else "histogram"
-        p <- p |> ggExtra::ggMarginal(
-          type = margin_type, margins = "both",
-          size = 8, groupColour = input$by_species, groupFill = input$by_species
-        )
+  
+  observeEvent(input$deselect_all_cols, {
+    updateCheckboxGroupInput(session, "columns_to_remove", selected = character(0))
+  })
+  
+  observeEvent(input$select_spinaxis, {
+    spinaxis_cols <- columns_to_remove[grepl("SpinAxis3d", columns_to_remove)]
+    updateCheckboxGroupInput(session, "columns_to_remove", selected = spinaxis_cols)
+  })
+  
+  observeEvent(input$select_attack_angle, {
+    attack_angle_cols <- columns_to_remove[grepl("AttackAngle|Attack Angle", columns_to_remove)]
+    updateCheckboxGroupInput(session, "columns_to_remove", selected = attack_angle_cols)
+  })
+  
+  # Process uploaded file
+  observeEvent(input$file, {
+    req(input$file)
+    
+    tryCatch({
+      # Read the uploaded file
+      df <- read.csv(input$file$datapath,
+                     header = input$header,
+                     sep = input$sep,
+                     quote = input$quote,
+                     stringsAsFactors = FALSE)
+      
+      # Process the data using selected columns to remove
+      selected_cols_to_remove <- input$columns_to_remove %||% character(0)
+      processed_df <- df
+      
+      # Remove selected columns
+      if (length(selected_cols_to_remove) > 0) {
+        columns_to_drop <- intersect(names(df), selected_cols_to_remove)
+        if (length(columns_to_drop) > 0) {
+          processed_df <- processed_df %>% select(-all_of(columns_to_drop))
+        }
       }
-
-      p
+      
+      # Remove duplicates only
+      processed_df <- processed_df %>% distinct()
+      
+      processed_data(processed_df)
+      plot_data(processed_df)
+      
+      # Update pitcher choices
+      if ("Pitcher" %in% names(processed_df)) {
+        pitcher_choices <- sort(unique(processed_df$Pitcher[!is.na(processed_df$Pitcher)]))
+        updateSelectInput(session, "pitcher_select", choices = pitcher_choices, selected = pitcher_choices[1])
+      }
+      
+    }, error = function(e) {
+      showNotification(paste("Error processing file:", e$message), type = "error")
+    })
+  })
+  
+  # Processing summary
+  output$process_summary <- renderText({
+    if (is.null(input$file)) {
+      return("No file uploaded yet.")
+    }
+    
+    if (is.null(processed_data())) {
+      return("Processing...")
+    }
+    
+    df <- processed_data()
+    original_df <- read.csv(input$file$datapath, nrows = 1)
+    selected_cols_to_remove <- input$columns_to_remove %||% character(0)
+    removed_cols <- intersect(selected_cols_to_remove, names(original_df))
+    
+    summary_text <- paste(
+      "✓ File processed successfully!",
+      paste("✓ Original columns:", ncol(original_df)),
+      paste("✓ Final columns:", ncol(df)),
+      paste("✓ Target columns: 167"),
+      paste("✓ Rows processed:", nrow(df)),
+      paste("✓ Removed columns:", length(removed_cols)),
+      if (length(removed_cols) > 0) paste("  -", paste(head(removed_cols, 5), collapse = ", "), 
+                                          if (length(removed_cols) > 5) "..." else ""),
+      "✓ Duplicates removed",
+      paste("✓ Ready for further processing"),
+      sep = "\n"
+    )
+    
+    return(summary_text)
+  })
+  
+  # Preview table
+  output$preview <- DT::renderDataTable({
+    req(processed_data())
+    
+    DT::datatable(processed_data(), 
+                  options = list(scrollX = TRUE, pageLength = 10),
+                  filter = "top")
+  })
+  
+  # Movement plot
+  output$movement_plot <- renderPlot({
+    req(plot_data(), input$pitcher_select)
+    
+    pitcher_data <- plot_data() %>% 
+      filter(Pitcher == input$pitcher_select) %>%
+      filter(!is.na(TaggedPitchType), TaggedPitchType != "Other",
+             !is.na(HorzBreak), !is.na(InducedVertBreak), !is.na(RelSpeed)) %>%
+      mutate(pitch_id = row_number())
+    
+    if (nrow(pitcher_data) == 0) {
+      plot.new()
+      text(0.5, 0.5, "No data available for selected pitcher", cex = 1.5)
+      return()
+    }
+    
+    # Get colors for each pitch type
+    pitcher_data$color <- pitch_colors[pitcher_data$TaggedPitchType]
+    pitcher_data$color[is.na(pitcher_data$color)] <- "#D3D3D3"
+    
+    # Create the plot without grid parameter
+    par(mar = c(5, 5, 4, 8), xpd = TRUE)
+    plot(pitcher_data$HorzBreak, pitcher_data$InducedVertBreak,
+         col = pitcher_data$color,
+         pch = 19, cex = 1.5,
+         xlim = c(-25, 25), ylim = c(-25, 25),
+         xlab = "Horizontal Break (inches)",
+         ylab = "Induced Vertical Break (inches)",
+         main = paste("Pitch Movement Chart -", input$pitcher_select))
+    
+    # Add grid lines manually
+    grid(nx = NULL, ny = NULL, col = "lightgray", lty = 1, lwd = 0.5)
+    abline(h = 0, col = "gray", lty = 2, lwd = 1)
+    abline(v = 0, col = "gray", lty = 2, lwd = 1)
+    
+    # Add concentric circles
+    for (r in c(6, 12, 18, 24)) {
+      circle_x <- r * cos(seq(0, 2*pi, length.out = 100))
+      circle_y <- r * sin(seq(0, 2*pi, length.out = 100))
+      lines(circle_x, circle_y, col = "lightgray", lty = 3)
+    }
+    
+    # Add points to show selection
+    if (input$selection_mode == "drag" && !is.null(selected_points())) {
+      sel_points <- selected_points()
+      points(sel_points$HorzBreak, sel_points$InducedVertBreak,
+             pch = 21, cex = 2, col = "red", lwd = 3)
+    }
+    
+    # Create legend
+    unique_pitches <- unique(pitcher_data$TaggedPitchType)
+    unique_colors <- pitch_colors[unique_pitches]
+    legend("topright", inset = c(-0.15, 0),
+           legend = unique_pitches,
+           col = unique_colors,
+           pch = 19,
+           cex = 0.8,
+           title = "Pitch Type")
+  })
+  
+  # Handle plot clicks (single mode only)
+  observeEvent(input$plot_click, {
+    req(plot_data(), input$pitcher_select, input$plot_click)
+    
+    # Only handle clicks in single mode
+    if (input$selection_mode != "single") return()
+    
+    pitcher_data <- plot_data() %>% 
+      filter(Pitcher == input$pitcher_select) %>%
+      filter(!is.na(TaggedPitchType), TaggedPitchType != "Other",
+             !is.na(HorzBreak), !is.na(InducedVertBreak), !is.na(RelSpeed)) %>%
+      mutate(pitch_id = row_number())
+    
+    if (nrow(pitcher_data) == 0) return()
+    
+    # Find closest point to click
+    click_x <- input$plot_click$x
+    click_y <- input$plot_click$y
+    
+    distances <- sqrt((pitcher_data$HorzBreak - click_x)^2 + 
+                        (pitcher_data$InducedVertBreak - click_y)^2)
+    
+    closest_idx <- which.min(distances)
+    
+    # Only proceed if click is reasonably close (within 2 inches)
+    if (min(distances) <= 2) {
+      clicked_pitch <- pitcher_data[closest_idx, ]
+      
+      # Store the original row index in the full dataset
+      full_data <- plot_data() %>% filter(Pitcher == input$pitcher_select)
+      original_row <- which(full_data$HorzBreak == clicked_pitch$HorzBreak & 
+                              full_data$InducedVertBreak == clicked_pitch$InducedVertBreak &
+                              full_data$RelSpeed == clicked_pitch$RelSpeed)[1]
+      
+      selected_pitch(list(
+        pitcher = input$pitcher_select,
+        row_in_pitcher_data = original_row,
+        data = clicked_pitch,
+        original_type = clicked_pitch$TaggedPitchType
+      ))
+      
+      # Update modal dropdown to current pitch type
+      updateSelectInput(session, "modal_new_pitch_type", 
+                        selected = clicked_pitch$TaggedPitchType)
+      
+      # Show modal
+      toggleModal(session, "pitchEditModal", toggle = "open")
+    }
+  })
+  
+  # Handle brush selection (drag mode)
+  observeEvent(input$plot_brush, {
+    req(plot_data(), input$pitcher_select, input$plot_brush)
+    
+    # Only handle brush in drag mode
+    if (input$selection_mode != "drag") return()
+    
+    pitcher_data <- plot_data() %>% 
+      filter(Pitcher == input$pitcher_select) %>%
+      filter(!is.na(TaggedPitchType), TaggedPitchType != "Other",
+             !is.na(HorzBreak), !is.na(InducedVertBreak), !is.na(RelSpeed))
+    
+    if (nrow(pitcher_data) == 0) return()
+    
+    # Find points within brush area
+    brush <- input$plot_brush
+    brushed_points <- pitcher_data %>%
+      filter(
+        HorzBreak >= brush$xmin & HorzBreak <= brush$xmax &
+          InducedVertBreak >= brush$ymin & InducedVertBreak <= brush$ymax
+      )
+    
+    if (nrow(brushed_points) > 0) {
+      selected_points(brushed_points)
+    } else {
+      selected_points(NULL)
+    }
+  })
+  
+  # Apply bulk change
+  observeEvent(input$apply_bulk_change, {
+    req(selected_points(), input$bulk_pitch_type)
+    
+    sel_points <- selected_points()
+    
+    if (nrow(sel_points) == 0) {
+      showNotification("No points selected", type = "warning")
+      return()
+    }
+    
+    # Get current data
+    current_data <- plot_data()
+    
+    # Update all selected points
+    for (i in 1:nrow(sel_points)) {
+      point <- sel_points[i, ]
+      current_data <- current_data %>%
+        mutate(TaggedPitchType = ifelse(
+          Pitcher == input$pitcher_select &
+            abs(HorzBreak - point$HorzBreak) < 0.01 &
+            abs(InducedVertBreak - point$InducedVertBreak) < 0.01 &
+            abs(RelSpeed - point$RelSpeed) < 0.01,
+          input$bulk_pitch_type,
+          TaggedPitchType
+        ))
+    }
+    
+    # Update reactive values
+    plot_data(current_data)
+    processed_data(current_data)
+    
+    # Clear selection
+    selected_points(NULL)
+    
+    # Show success message
+    showNotification(
+      paste("Updated", nrow(sel_points), "pitches to", input$bulk_pitch_type), 
+      type = "message", duration = 3
+    )
+  })
+  
+  # Selection info for drag mode
+  output$selection_info <- renderText({
+    if (input$selection_mode == "drag" && !is.null(selected_points())) {
+      sel_points <- selected_points()
+      pitch_counts <- table(sel_points$TaggedPitchType)
+      paste(nrow(sel_points), "points selected:",
+            paste(names(pitch_counts), "(", pitch_counts, ")", collapse = ", "))
+    } else {
+      "No points selected. Click and drag to select multiple pitches."
+    }
+  })
+  
+  # Hover info
+  output$hover_info <- renderText({
+    req(input$plot_hover, plot_data(), input$pitcher_select)
+    
+    pitcher_data <- plot_data() %>% 
+      filter(Pitcher == input$pitcher_select) %>%
+      filter(!is.na(TaggedPitchType), TaggedPitchType != "Other",
+             !is.na(HorzBreak), !is.na(InducedVertBreak), !is.na(RelSpeed))
+    
+    if (nrow(pitcher_data) == 0) return("")
+    
+    hover_x <- input$plot_hover$x
+    hover_y <- input$plot_hover$y
+    
+    distances <- sqrt((pitcher_data$HorzBreak - hover_x)^2 + 
+                        (pitcher_data$InducedVertBreak - hover_y)^2)
+    
+    if (min(distances) <= 2) {
+      closest_idx <- which.min(distances)
+      hover_pitch <- pitcher_data[closest_idx, ]
+      
+      paste("Hovering over:",
+            paste("Type:", hover_pitch$TaggedPitchType),
+            paste("Velocity:", round(hover_pitch$RelSpeed, 1), "mph"),
+            paste("HB:", round(hover_pitch$HorzBreak, 1), "in"),
+            paste("IVB:", round(hover_pitch$InducedVertBreak, 1), "in"),
+            sep = " | ")
+    } else {
+      ""
+    }
+  })
+  
+  # Movement stats table
+  output$movement_stats <- DT::renderDataTable({
+    req(plot_data(), input$pitcher_select)
+    
+    data <- plot_data()
+    
+    movement_stats <- data %>%
+      filter(Pitcher == input$pitcher_select) %>%
+      filter(!is.na(HorzBreak), !is.na(InducedVertBreak), !is.na(TaggedPitchType)) %>%
+      mutate(
+        pitch_group = case_when(
+          TaggedPitchType %in% c("Fastball", "FourSeamFastBall", "FourSeamFastB", "Four-Seam", "4-Seam") ~ "Fastball",
+          TaggedPitchType %in% c("OneSeamFastBall", "TwoSeamFastBall", "Sinker", "Two-Seam", "One-Seam") ~ "Sinker", 
+          TaggedPitchType %in% c("ChangeUp", "Changeup") ~ "Changeup",
+          TRUE ~ TaggedPitchType
+        ),
+        # Create necessary indicator variables if they don't exist
+        in_zone = if ("StrikeZoneIndicator" %in% names(.)) StrikeZoneIndicator else 
+          ifelse(!is.na(PlateLocSide) & !is.na(PlateLocHeight) & 
+                   PlateLocSide >= -0.95 & PlateLocSide <= 0.95 &
+                   PlateLocHeight >= 1.6 & PlateLocHeight <= 3.5, 1, 0),
+        is_whiff = if ("WhiffIndicator" %in% names(.)) WhiffIndicator else 
+          ifelse(!is.na(PitchCall) & PitchCall == "StrikeSwinging", 1, 0),
+        chase = if ("Chaseindicator" %in% names(.)) Chaseindicator else
+          ifelse(!is.na(PitchCall) & !is.na(PlateLocSide) & !is.na(PlateLocHeight) &
+                   PitchCall %in% c("StrikeSwinging", "FoulBallNotFieldable", "FoulBall", "InPlay") &
+                   (PlateLocSide < -0.95 | PlateLocSide > 0.95 | PlateLocHeight < 1.6 | PlateLocHeight > 3.5), 1, 0)
+      )
+    
+    # Calculate total pitches for usage percentage
+    total_pitches <- nrow(movement_stats)
+    
+    summary_stats <- movement_stats %>%
+      group_by(`Pitch Type` = pitch_group) %>%
+      summarise(
+        Count = n(),
+        `Usage%` = sprintf("%.1f%%", (n() / total_pitches) * 100),
+        `Ext.` = if ("Extension" %in% names(.)) sprintf("%.1f", mean(Extension, na.rm = TRUE)) else "—",
+        `Avg Velo` = sprintf("%.1f mph", mean(RelSpeed, na.rm = TRUE)),
+        `90th Velo` = sprintf("%.1f mph", quantile(RelSpeed, 0.9, na.rm = TRUE)),
+        `Max Velo` = sprintf("%.1f mph", max(RelSpeed, na.rm = TRUE)),
+        `Avg IVB` = sprintf("%.1f in", mean(InducedVertBreak, na.rm = TRUE)),
+        `Avg HB` = sprintf("%.1f in", mean(HorzBreak, na.rm = TRUE)),
+        `Avg Spin` = if ("SpinRate" %in% names(.)) sprintf("%.0f rpm", mean(SpinRate, na.rm = TRUE)) else "—",
+        `Rel Height` = if ("RelHeight" %in% names(.)) sprintf("%.1f", mean(RelHeight, na.rm = TRUE)) else "—",
+        `Zone%` = sprintf("%.1f%%", round(mean(in_zone, na.rm = TRUE) * 100, 1)),
+        `Whiff%` = sprintf("%.1f%%", round(mean(is_whiff, na.rm = TRUE) * 100, 1)),
+        `Chase%` = sprintf("%.1f%%", round(mean(chase, na.rm = TRUE) * 100, 1)),
+        .groups = "drop"
+      ) %>%
+      arrange(desc(Count))
+    
+    DT::datatable(summary_stats, 
+                  options = list(pageLength = 15, dom = 't', scrollX = TRUE),
+                  rownames = FALSE) %>%
+      DT::formatStyle(columns = names(summary_stats), fontSize = '12px')
+  })
+  
+  # Selected pitch info in modal
+  output$selected_pitch_info <- renderText({
+    pitch_info <- selected_pitch()
+    if (!is.null(pitch_info)) {
+      pitch_data <- pitch_info$data
+      
+      info_text <- paste(
+        paste("Pitcher:", pitch_info$pitcher),
+        paste("Current Type:", pitch_data$TaggedPitchType),
+        paste("Velocity:", round(pitch_data$RelSpeed, 1), "mph"),
+        paste("Horizontal Break:", round(pitch_data$HorzBreak, 1), "inches"),
+        paste("Induced Vertical Break:", round(pitch_data$InducedVertBreak, 1), "inches"),
+        if ("SpinRate" %in% names(pitch_data) && !is.na(pitch_data$SpinRate)) {
+          paste("Spin Rate:", round(pitch_data$SpinRate, 0), "rpm")
+        } else "",
+        if ("Date" %in% names(pitch_data) && !is.na(pitch_data$Date)) {
+          paste("Date:", format(as.Date(pitch_data$Date)))
+        } else "",
+        sep = "\n"
+      )
+      
+      return(info_text)
+    } else {
+      return("No pitch selected")
+    }
+  })
+  
+  # Update pitch type
+  observeEvent(input$update_pitch, {
+    pitch_info <- selected_pitch()
+    
+    if (!is.null(pitch_info)) {
+      # Get the full dataset
+      current_data <- plot_data()
+      
+      # Find and update the specific pitch more reliably
+      # Use multiple criteria to identify the exact row
+      target_pitcher <- pitch_info$pitcher
+      target_hb <- pitch_info$data$HorzBreak
+      target_ivb <- pitch_info$data$InducedVertBreak
+      target_velo <- pitch_info$data$RelSpeed
+      
+      # Update the TaggedPitchType for the matching row
+      current_data <- current_data %>%
+        mutate(TaggedPitchType = ifelse(
+          Pitcher == target_pitcher & 
+            abs(HorzBreak - target_hb) < 0.01 & 
+            abs(InducedVertBreak - target_ivb) < 0.01 & 
+            abs(RelSpeed - target_velo) < 0.01,
+          input$modal_new_pitch_type,
+          TaggedPitchType
+        ))
+      
+      # Update reactive values
+      plot_data(current_data)
+      processed_data(current_data)
+      
+      # Close modal
+      toggleModal(session, "pitchEditModal", toggle = "close")
+      
+      # Show success message
+      showNotification(
+        paste("Updated pitch from", pitch_info$original_type, "to", input$modal_new_pitch_type), 
+        type = "message", duration = 3
+      )
+      
+      # Clear selection
+      selected_pitch(NULL)
+    }
+  })
+  
+  # Cancel edit
+  observeEvent(input$cancel_edit, {
+    toggleModal(session, "pitchEditModal", toggle = "close")
+    selected_pitch(NULL)
+  })
+  
+  # Click info output
+  output$click_info <- renderText({
+    if (!is.null(selected_pitch())) {
+      pitch_info <- selected_pitch()
+      paste("Last selected pitch:", pitch_info$original_type,
+            "| Position: (", round(pitch_info$data$HorzBreak, 1), ",", 
+            round(pitch_info$data$InducedVertBreak, 1), ")")
+    } else {
+      "No point selected yet. Click on a point in the chart above to edit its pitch type."
+    }
+  })
+  
+  # Data summary for download page
+  output$data_summary <- renderText({
+    req(processed_data())
+    df <- processed_data()
+    
+    summary_text <- paste(
+      paste("Total rows:", nrow(df)),
+      paste("Total columns:", ncol(df)),
+      paste("Date range:", 
+            if ("Date" %in% names(df) && !all(is.na(df$Date))) {
+              paste(min(as.Date(df$Date), na.rm = TRUE), "to", max(as.Date(df$Date), na.rm = TRUE))
+            } else {
+              "Date column not available"
+            }),
+      paste("Unique pitchers:", 
+            if ("Pitcher" %in% names(df)) {
+              length(unique(df$Pitcher[!is.na(df$Pitcher)]))
+            } else {
+              "Pitcher column not available"
+            }),
+      paste("Pitch types:", 
+            if ("TaggedPitchType" %in% names(df)) {
+              paste(sort(unique(df$TaggedPitchType[!is.na(df$TaggedPitchType)])), collapse = ", ")
+            } else {
+              "TaggedPitchType column not available"
+            }),
+      sep = "\n"
+    )
+    
+    return(summary_text)
+  })
+  
+  # Download handler
+  output$downloadData <- downloadHandler(
+    filename = function() {
+      paste("app_ready_COA", Sys.Date(), ".csv", sep = "")
     },
-    res = 100
+    content = function(file) {
+      write.csv(processed_data(), file, row.names = FALSE)
+    }
   )
 }
 
-shinyApp(ui, server)
+# Run the app
+shinyApp(ui = ui, server = server)