Update app.R

app.R

@@ -5,6 +5,7 @@ library(DT)
 library(dplyr)
 library(readr)
 library(stringr)
+library(jsonlite)
 
 # Define columns to remove if they exist
 columns_to_remove <- c(
@@ -21,8 +22,7 @@ columns_to_remove <- c(
   "SpinAxis3dSeamOrientationBallXAmb2", "SpinAxis3dSeamOrientationBallAngleVerticalAmb3",
   "SpinAxis3dSeamOrientationBallAngleHorizontalAmb3", "SpinAxis3dSeamOrientationBallXAmb3",
   "SpinAxis3dSeamOrientationBallYAmb3", "SpinAxis3dSeamOrientationBallZAmb3",
-  "SpinAxis3dSeamOrientationBallZAmb4", "BatSpeed", "GameDate", "HorizontalAttackAngle",
-  "Horizontal Attack Angle", "VerticalAttackAngle", "Vertical attack angle"
+  "SpinAxis3dSeamOrientationBallZAmb4", "GameDate"
 )
 
 # Pitch colors for visualization (Coastal Carolina theme)
@@ -40,18 +40,109 @@ pitch_colors <- c(
   "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))
+# Function to parse bat tracking JSON
+parse_bat_tracking_json <- function(json_path) {
+  tryCatch({
+    json_data <- fromJSON(json_path, simplifyVector = FALSE)
+    
+    # Extract metadata
+    game_reference <- json_data$GameReference
+    session_id <- json_data$SessionId
+    
+    # Extract plays
+    plays <- json_data$Plays
+    
+    if (length(plays) == 0) {
+      return(list(
+        success = TRUE,
+        data = NULL,
+        game_reference = game_reference,
+        message = "JSON parsed but contains no bat tracking plays (empty Plays array)"
+      ))
+    }
+    
+    # Build data frame from plays
+    bat_tracking_df <- data.frame(
+      PitchUID = sapply(plays, function(p) p$PitchUID),
+      BatSpeed_Sensor = sapply(plays, function(p) p$BatSpeed),
+      VerticalAttackAngle_Sensor = sapply(plays, function(p) p$VerticalAttackAngle),
+      HorizontalAttackAngle_Sensor = sapply(plays, function(p) p$HorizontalAttackAngle),
+      BatTracking_PlayId = sapply(plays, function(p) p$PlayId),
+      BatTracking_Time = sapply(plays, function(p) p$Time),
+      stringsAsFactors = FALSE
+    )
+    
+    return(list(
+      success = TRUE,
+      data = bat_tracking_df,
+      game_reference = game_reference,
+      session_id = session_id,
+      plays_count = length(plays),
+      message = paste("Successfully parsed", length(plays), "bat tracking play(s)")
+    ))
+    
+  }, error = function(e) {
+    return(list(
+      success = FALSE,
+      data = NULL,
+      message = paste("Error parsing JSON:", e$message)
+    ))
+  })
+}
+
+# Function to merge CSV with bat tracking
+merge_with_bat_tracking <- function(csv_data, bat_tracking_data) {
+  if (is.null(bat_tracking_data) || nrow(bat_tracking_data) == 0) {
+    return(list(
+      data = csv_data,
+      matched = 0,
+      total_bat = 0,
+      message = "No bat tracking data to merge"
+    ))
   }
   
-  # Remove duplicates only
-  df <- df %>% distinct()
+  # Check if PitchUID exists in CSV
+  if (!"PitchUID" %in% names(csv_data)) {
+    return(list(
+      data = csv_data,
+      matched = 0,
+      total_bat = nrow(bat_tracking_data),
+      message = "CSV does not contain PitchUID column - cannot merge"
+    ))
+  }
+  
+  # Perform left join
+  merged_data <- csv_data %>%
+    left_join(bat_tracking_data, by = "PitchUID")
+  
+  # Count matches
+  matched_count <- sum(!is.na(merged_data$BatSpeed_Sensor))
+  
+  # If original BatSpeed column exists and is empty, fill with sensor data
+  if ("BatSpeed" %in% names(merged_data)) {
+    merged_data <- merged_data %>%
+      mutate(BatSpeed = ifelse(is.na(BatSpeed) & !is.na(BatSpeed_Sensor), 
+                                BatSpeed_Sensor, BatSpeed))
+  }
+  
+  if ("VerticalAttackAngle" %in% names(merged_data)) {
+    merged_data <- merged_data %>%
+      mutate(VerticalAttackAngle = ifelse(is.na(VerticalAttackAngle) & !is.na(VerticalAttackAngle_Sensor), 
+                                           VerticalAttackAngle_Sensor, VerticalAttackAngle))
+  }
+  
+  if ("HorizontalAttackAngle" %in% names(merged_data)) {
+    merged_data <- merged_data %>%
+      mutate(HorizontalAttackAngle = ifelse(is.na(HorizontalAttackAngle) & !is.na(HorizontalAttackAngle_Sensor), 
+                                             HorizontalAttackAngle_Sensor, HorizontalAttackAngle))
+  }
   
-  return(df)
+  return(list(
+    data = merged_data,
+    matched = matched_count,
+    total_bat = nrow(bat_tracking_data),
+    message = paste("Merged successfully:", matched_count, "of", nrow(bat_tracking_data), "bat tracking records matched")
+  ))
 }
 
 # UI
@@ -70,7 +161,7 @@ ui <- fluidPage(
       justify-content: space-between;
       align-items: center;
       padding: 20px 40px;
-      background: #ffffff);
+      background: #ffffff;
       border-bottom: 3px solid darkcyan;
       margin-bottom: 20px;
     }
@@ -214,7 +305,7 @@ ui <- fluidPage(
     }
     
     h4 {
-      color: white;
+      color: darkcyan;
       font-weight: 500;
       margin-top: 20px;
       margin-bottom: 12px;
@@ -257,6 +348,38 @@ ui <- fluidPage(
     
     .brand-teal { color: darkcyan; }
     .brand-bronze { color: peru; }
+    
+    /* Bat tracking upload box styling */
+    .bat-tracking-box {
+      background: linear-gradient(135deg, #e8f4f8 0%, #f0e6d3 100%);
+      border: 2px dashed darkcyan;
+      border-radius: 15px;
+      padding: 20px;
+      margin-top: 15px;
+    }
+    
+    .merge-status-box {
+      background: #f8f9fa;
+      border-left: 4px solid darkcyan;
+      padding: 15px;
+      border-radius: 0 10px 10px 0;
+      margin-top: 15px;
+    }
+    
+    .merge-success {
+      border-left-color: #28a745;
+      background: #d4edda;
+    }
+    
+    .merge-warning {
+      border-left-color: #ffc107;
+      background: #fff3cd;
+    }
+    
+    .merge-error {
+      border-left-color: #dc3545;
+      background: #f8d7da;
+    }
   "))
   ),
   
@@ -273,8 +396,8 @@ ui <- fluidPage(
               tabPanel(
                 "Upload & Process",
                 fluidRow(
-                  column(12,
-                         h3("Upload CSV File"),
+                  column(6,
+                         h3("1. Upload TrackMan CSV"),
                          fileInput("file", "Choose CSV File", accept = c(".csv")),
                          fluidRow(
                            column(4,
@@ -290,13 +413,26 @@ ui <- fluidPage(
                                                choices = c(None = "", "Double Quote" = '"', "Single Quote" = "'"),
                                                selected = '"', inline = TRUE)
                            )
+                         ),
+                         verbatimTextOutput("csv_status")
+                  ),
+                  column(6,
+                         div(class = "bat-tracking-box",
+                             h3("2. Upload Bat Tracking JSON (Optional)", style = "margin-top: 0;"),
+                             fileInput("json_file", "Choose Bat Tracking JSON File", accept = c(".json")),
+                             p(style = "color: #666; font-size: 12px;", 
+                               "Upload the corresponding _battracking.json file to merge bat speed and attack angle data."),
+                             verbatimTextOutput("json_status"),
+                             uiOutput("merge_status_ui")
                          )
                   )
                 ),
                 
+                hr(),
+                
                 fluidRow(
                   column(8,
-                         h3("Columns to Remove"),
+                         h3("3. Columns to Remove"),
                          p("Select which columns to remove from your dataset:"),
                          checkboxGroupInput("columns_to_remove", "Remove These Columns:",
                                             choices = columns_to_remove,
@@ -311,14 +447,26 @@ ui <- fluidPage(
                          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")
                   )
                 )
               ),
               
+              # Bat Tracking Details Tab
+              tabPanel(
+                "Bat Tracking Data",
+                fluidRow(
+                  column(12,
+                         h3("Bat Tracking Merge Details"),
+                         uiOutput("bat_tracking_details"),
+                         hr(),
+                         h4("Pitches with Bat Tracking Data"),
+                         DT::dataTableOutput("bat_tracking_table")
+                  )
+                )
+              ),
+              
               # Preview Data Tab
               tabPanel(
                 "Preview Data",
@@ -435,6 +583,9 @@ server <- function(input, output, session) {
   plot_data <- reactiveVal(NULL)
   selected_pitch <- reactiveVal(NULL)
   selected_points <- reactiveVal(NULL)
+  csv_data_raw <- reactiveVal(NULL)
+  bat_tracking_parsed <- reactiveVal(NULL)
+  merge_result <- reactiveVal(NULL)
   
   # Handle column selection buttons
   observeEvent(input$select_all_cols, {
@@ -451,28 +602,30 @@ server <- function(input, output, session) {
     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
+  # Process uploaded CSV 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
+      csv_data_raw(df)
+      
+      # If we already have bat tracking data, try to merge
+      if (!is.null(bat_tracking_parsed()) && !is.null(bat_tracking_parsed()$data)) {
+        result <- merge_with_bat_tracking(df, bat_tracking_parsed()$data)
+        merge_result(result)
+        df <- result$data
+      }
+      
+      # Process the data (remove columns)
       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) {
@@ -480,7 +633,6 @@ server <- function(input, output, session) {
         }
       }
       
-      # Remove duplicates only
       processed_df <- processed_df %>% distinct()
       
       processed_data(processed_df)
@@ -493,10 +645,236 @@ server <- function(input, output, session) {
       }
       
     }, error = function(e) {
-      showNotification(paste("Error processing file:", e$message), type = "error")
+      showNotification(paste("Error processing CSV:", e$message), type = "error")
+    })
+  })
+  
+  # Process uploaded JSON file
+  observeEvent(input$json_file, {
+    req(input$json_file)
+    
+    tryCatch({
+      parsed <- parse_bat_tracking_json(input$json_file$datapath)
+      bat_tracking_parsed(parsed)
+      
+      # If we already have CSV data, merge
+      if (!is.null(csv_data_raw()) && parsed$success && !is.null(parsed$data)) {
+        result <- merge_with_bat_tracking(csv_data_raw(), parsed$data)
+        merge_result(result)
+        
+        # Re-process with merged data
+        df <- result$data
+        selected_cols_to_remove <- input$columns_to_remove %||% character(0)
+        
+        if (length(selected_cols_to_remove) > 0) {
+          columns_to_drop <- intersect(names(df), selected_cols_to_remove)
+          if (length(columns_to_drop) > 0) {
+            df <- df %>% select(-all_of(columns_to_drop))
+          }
+        }
+        
+        df <- df %>% distinct()
+        
+        processed_data(df)
+        plot_data(df)
+        
+        showNotification(result$message, type = "message", duration = 5)
+      }
+      
+    }, error = function(e) {
+      showNotification(paste("Error processing JSON:", e$message), type = "error")
     })
   })
   
+  # CSV status output
+  output$csv_status <- renderText({
+    if (is.null(input$file)) {
+      return("No CSV file uploaded yet.")
+    }
+    
+    if (is.null(csv_data_raw())) {
+      return("Processing CSV...")
+    }
+    
+    df <- csv_data_raw()
+    game_id <- if ("GameID" %in% names(df)) unique(df$GameID)[1] else "Unknown"
+    
+    paste(
+      "✓ CSV loaded successfully!",
+      paste("  Game ID:", game_id),
+      paste("  Rows:", nrow(df)),
+      paste("  Columns:", ncol(df)),
+      sep = "\n"
+    )
+  })
+  
+  # JSON status output
+  output$json_status <- renderText({
+    if (is.null(input$json_file)) {
+      return("No JSON file uploaded yet.")
+    }
+    
+    parsed <- bat_tracking_parsed()
+    if (is.null(parsed)) {
+      return("Processing JSON...")
+    }
+    
+    if (!parsed$success) {
+      return(paste("✗", parsed$message))
+    }
+    
+    paste(
+      "✓ JSON parsed successfully!",
+      paste("  Game Reference:", parsed$game_reference),
+      paste("  Plays found:", parsed$plays_count %||% 0),
+      sep = "\n"
+    )
+  })
+  
+  # Merge status UI
+  output$merge_status_ui <- renderUI({
+    result <- merge_result()
+    parsed <- bat_tracking_parsed()
+    csv <- csv_data_raw()
+    
+    if (is.null(parsed) || is.null(csv)) {
+      return(NULL)
+    }
+    
+    if (!parsed$success) {
+      return(div(class = "merge-status-box merge-error",
+                 h4("Merge Status", style = "margin-top: 0; color: #721c24;"),
+                 p(parsed$message)
+      ))
+    }
+    
+    if (is.null(parsed$data) || is.null(result)) {
+      # Check game ID match
+      csv_game <- if ("GameID" %in% names(csv)) unique(csv$GameID)[1] else NULL
+      json_game <- parsed$game_reference
+      
+      if (!is.null(csv_game) && !is.null(json_game) && csv_game != json_game) {
+        return(div(class = "merge-status-box merge-warning",
+                   h4("⚠ Game ID Mismatch", style = "margin-top: 0; color: #856404;"),
+                   p(paste("CSV Game:", csv_game)),
+                   p(paste("JSON Game:", json_game)),
+                   p("Files may be from different games!")
+        ))
+      }
+      
+      return(div(class = "merge-status-box merge-warning",
+                 h4("No Data to Merge", style = "margin-top: 0; color: #856404;"),
+                 p(parsed$message)
+      ))
+    }
+    
+    # Check game ID match
+    csv_game <- if ("GameID" %in% names(csv)) unique(csv$GameID)[1] else NULL
+    json_game <- parsed$game_reference
+    game_match <- is.null(csv_game) || is.null(json_game) || csv_game == json_game
+    
+    if (result$matched > 0) {
+      div(class = "merge-status-box merge-success",
+          h4("✓ Merge Successful!", style = "margin-top: 0; color: #155724;"),
+          p(paste("Matched:", result$matched, "of", result$total_bat, "bat tracking records")),
+          if (!game_match) p(style = "color: #856404;", "⚠ Note: Game IDs differ but PitchUIDs matched")
+      )
+    } else {
+      div(class = "merge-status-box merge-warning",
+          h4("⚠ No Matches Found", style = "margin-top: 0; color: #856404;"),
+          p(paste("0 of", result$total_bat, "bat tracking records matched")),
+          if (!game_match) p(paste("Game ID mismatch: CSV =", csv_game, ", JSON =", json_game))
+      )
+    }
+  })
+  
+  # Bat tracking details
+  output$bat_tracking_details <- renderUI({
+    parsed <- bat_tracking_parsed()
+    result <- merge_result()
+    
+    if (is.null(parsed)) {
+      return(div(
+        p("No bat tracking JSON file uploaded."),
+        p("Upload a _battracking.json file in the 'Upload & Process' tab to see bat tracking data here.")
+      ))
+    }
+    
+    if (!parsed$success) {
+      return(div(class = "alert alert-danger", parsed$message))
+    }
+    
+    if (is.null(parsed$data)) {
+      return(div(class = "alert alert-warning", 
+                 h4("Empty Bat Tracking File"),
+                 p(parsed$message),
+                 p("The JSON file was valid but contained no swing data in the Plays array.")
+      ))
+    }
+    
+    # Show summary
+    div(
+      div(class = "row",
+          div(class = "col-md-4",
+              div(class = "well",
+                  h4("Game Reference"),
+                  p(parsed$game_reference)
+              )
+          ),
+          div(class = "col-md-4",
+              div(class = "well",
+                  h4("Total Swings Tracked"),
+                  p(style = "font-size: 24px; font-weight: bold; color: darkcyan;", parsed$plays_count)
+              )
+          ),
+          div(class = "col-md-4",
+              div(class = "well",
+                  h4("Matched to CSV"),
+                  p(style = "font-size: 24px; font-weight: bold; color: #28a745;", 
+                    if (!is.null(result)) result$matched else "N/A")
+              )
+          )
+      )
+    )
+  })
+  
+  # Bat tracking table
+  output$bat_tracking_table <- DT::renderDataTable({
+    df <- processed_data()
+    
+    if (is.null(df)) {
+      return(NULL)
+    }
+    
+    # Filter to rows with bat tracking data
+    if ("BatSpeed_Sensor" %in% names(df)) {
+      bat_rows <- df %>%
+        filter(!is.na(BatSpeed_Sensor)) %>%
+        select(
+          any_of(c("PitchNo", "Time", "Pitcher", "Batter", "TaggedPitchType", "PitchCall",
+                   "RelSpeed", "ExitSpeed", "Angle",
+                   "BatSpeed", "BatSpeed_Sensor", 
+                   "VerticalAttackAngle", "VerticalAttackAngle_Sensor",
+                   "HorizontalAttackAngle", "HorizontalAttackAngle_Sensor"))
+        )
+      
+      if (nrow(bat_rows) == 0) {
+        return(NULL)
+      }
+      
+      DT::datatable(bat_rows,
+                    options = list(scrollX = TRUE, pageLength = 10),
+                    rownames = FALSE) %>%
+        DT::formatRound(columns = intersect(names(bat_rows), 
+                                            c("BatSpeed_Sensor", "VerticalAttackAngle_Sensor", 
+                                              "HorizontalAttackAngle_Sensor", "RelSpeed", 
+                                              "ExitSpeed", "Angle")), 
+                        digits = 1)
+    } else {
+      return(NULL)
+    }
+  })
+  
   # Processing summary
   output$process_summary <- renderText({
     if (is.null(input$file)) {
@@ -508,31 +886,38 @@ server <- function(input, output, session) {
     }
     
     df <- processed_data()
-    original_df <- read.csv(input$file$datapath, nrows = 1)
+    original_df <- csv_data_raw()
     selected_cols_to_remove <- input$columns_to_remove %||% character(0)
     removed_cols <- intersect(selected_cols_to_remove, names(original_df))
+    result <- merge_result()
     
-    # Build the removed columns text
     removed_cols_text <- if (length(removed_cols) > 0) {
       cols_display <- if (length(removed_cols) > 5) {
         paste(paste(head(removed_cols, 5), collapse = ", "), "...")
       } else {
         paste(removed_cols, collapse = ", ")
       }
-      paste("✓ Removed columns:", length(removed_cols), "\n  -", cols_display)
+      paste("✓ Removed columns:", length(removed_cols))
     } else {
       "✓ Removed columns: 0"
     }
     
+    bat_tracking_text <- if (!is.null(result) && result$matched > 0) {
+      paste("✓ Bat tracking merged:", result$matched, "pitches")
+    } else if (!is.null(bat_tracking_parsed())) {
+      "⚠ Bat tracking: No matches"
+    } else {
+      "○ Bat tracking: Not uploaded"
+    }
+    
     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)),
       removed_cols_text,
+      bat_tracking_text,
       "✓ Duplicates removed",
-      paste("✓ Ready for further processing"),
       sep = "\n"
     )
     
@@ -564,11 +949,9 @@ server <- function(input, output, session) {
       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,
@@ -578,26 +961,22 @@ server <- function(input, output, session) {
          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),
@@ -612,7 +991,6 @@ server <- function(input, output, session) {
   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() %>% 
@@ -623,7 +1001,6 @@ server <- function(input, output, session) {
     
     if (nrow(pitcher_data) == 0) return()
     
-    # Find closest point to click
     click_x <- input$plot_click$x
     click_y <- input$plot_click$y
     
@@ -632,15 +1009,9 @@ server <- function(input, output, session) {
     
     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, ]
       
-      # DEBUG: Print to console
-      print("Pitch selected!")
-      print(paste("Type:", clicked_pitch$TaggedPitchType))
-      
-      # 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 &
@@ -653,11 +1024,9 @@ server <- function(input, output, session) {
         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")
     }
   })
@@ -666,7 +1035,6 @@ server <- function(input, output, session) {
   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() %>% 
@@ -676,7 +1044,6 @@ server <- function(input, output, session) {
     
     if (nrow(pitcher_data) == 0) return()
     
-    # Find points within brush area
     brush <- input$plot_brush
     brushed_points <- pitcher_data %>%
       filter(
@@ -702,10 +1069,8 @@ server <- function(input, output, session) {
       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 %>%
@@ -719,14 +1084,10 @@ server <- function(input, output, session) {
         ))
     }
     
-    # 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
@@ -766,11 +1127,18 @@ server <- function(input, output, session) {
       closest_idx <- which.min(distances)
       hover_pitch <- pitcher_data[closest_idx, ]
       
+      # Include bat tracking info if available
+      bat_info <- ""
+      if ("BatSpeed_Sensor" %in% names(hover_pitch) && !is.na(hover_pitch$BatSpeed_Sensor)) {
+        bat_info <- paste(" | Bat Speed:", round(hover_pitch$BatSpeed_Sensor, 1), "mph")
+      }
+      
       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"),
+            bat_info,
             sep = " | ")
     } else {
       ""
@@ -793,7 +1161,6 @@ server <- function(input, output, session) {
           TaggedPitchType %in% c("ChangeUp", "Changeup") ~ "Changeup",
           TRUE ~ TaggedPitchType
         ),
-        # Create necessary indicator variables if they don't exist
         in_zone = ifelse("StrikeZoneIndicator" %in% names(.), StrikeZoneIndicator, 
                         ifelse(!is.na(PlateLocSide) & !is.na(PlateLocHeight) & 
                                  PlateLocSide >= -0.95 & PlateLocSide <= 0.95 &
@@ -806,31 +1173,29 @@ server <- function(input, output, session) {
                                (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)
     
+    # Check if bat tracking columns exist
+    has_bat_speed <- "BatSpeed_Sensor" %in% names(movement_stats)
+    
     summary_stats <- movement_stats %>%
       group_by(`Pitch Type` = pitch_group) %>%
       summarise(
         Count = n(),
         `Usage%` = sprintf("%.1f%%", (n() / total_pitches) * 100),
-        `Ext.` = ifelse("Extension" %in% names(movement_stats), 
-                        sprintf("%.1f", mean(Extension, na.rm = TRUE)), 
-                        "—"),
-        `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 Velo` = sprintf("%.1f", mean(RelSpeed, na.rm = TRUE)),
+        `Max Velo` = sprintf("%.1f", max(RelSpeed, na.rm = TRUE)),
+        `Avg IVB` = sprintf("%.1f", mean(InducedVertBreak, na.rm = TRUE)),
+        `Avg HB` = sprintf("%.1f", mean(HorzBreak, na.rm = TRUE)),
         `Avg Spin` = ifelse("SpinRate" %in% names(movement_stats),
-                           sprintf("%.0f rpm", mean(SpinRate, na.rm = TRUE)),
+                           sprintf("%.0f", mean(SpinRate, na.rm = TRUE)),
                            "—"),
-        `Rel Height` = ifelse("RelHeight" %in% names(movement_stats),
-                             sprintf("%.1f", mean(RelHeight, na.rm = TRUE)),
-                             "—"),
+        `Avg Bat Speed` = if (has_bat_speed) {
+          bat_vals <- BatSpeed_Sensor[!is.na(BatSpeed_Sensor)]
+          if (length(bat_vals) > 0) sprintf("%.1f", mean(bat_vals)) else "—"
+        } 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))
@@ -847,7 +1212,6 @@ server <- function(input, output, session) {
     if (!is.null(pitch_info)) {
       pitch_data <- pitch_info$data
       
-      # Build info text with only available fields
       info_lines <- c(
         paste("Pitcher:", pitch_info$pitcher),
         paste("Current Type:", pitch_data$TaggedPitchType),
@@ -856,11 +1220,18 @@ server <- function(input, output, session) {
         paste("Induced Vertical Break:", round(pitch_data$InducedVertBreak, 1), "inches")
       )
       
-      # Add optional fields only if they exist and have values
       if ("SpinRate" %in% names(pitch_data) && !is.na(pitch_data$SpinRate)) {
         info_lines <- c(info_lines, paste("Spin Rate:", round(pitch_data$SpinRate, 0), "rpm"))
       }
       
+      # Add bat tracking info if available
+      if ("BatSpeed_Sensor" %in% names(pitch_data) && !is.na(pitch_data$BatSpeed_Sensor)) {
+        info_lines <- c(info_lines, 
+                        paste("Bat Speed:", round(pitch_data$BatSpeed_Sensor, 1), "mph"),
+                        paste("Vertical Attack Angle:", round(pitch_data$VerticalAttackAngle_Sensor, 1), "°"),
+                        paste("Horizontal Attack Angle:", round(pitch_data$HorizontalAttackAngle_Sensor, 1), "°"))
+      }
+      
       if ("Date" %in% names(pitch_data) && !is.na(pitch_data$Date)) {
         info_lines <- c(info_lines, paste("Date:", pitch_data$Date))
       }
@@ -876,17 +1247,13 @@ server <- function(input, output, session) {
     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 & 
@@ -897,20 +1264,16 @@ server <- function(input, output, session) {
           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)
     }
   })
@@ -937,6 +1300,13 @@ server <- function(input, output, session) {
   output$data_summary <- renderText({
     req(processed_data())
     df <- processed_data()
+    result <- merge_result()
+    
+    bat_tracking_summary <- if (!is.null(result) && result$matched > 0) {
+      paste("Bat tracking data:", result$matched, "pitches with swing metrics")
+    } else {
+      "Bat tracking data: None"
+    }
     
     summary_text <- paste(
       paste("Total rows:", nrow(df)),
@@ -959,6 +1329,7 @@ server <- function(input, output, session) {
             } else {
               "TaggedPitchType column not available"
             }),
+      bat_tracking_summary,
       sep = "\n"
     )
     
@@ -968,7 +1339,7 @@ server <- function(input, output, session) {
   # Download handler
   output$downloadData <- downloadHandler(
     filename = function() {
-      paste("app_ready_COA", Sys.Date(), ".csv", sep = "")
+      paste("app_ready_COA_", Sys.Date(), ".csv", sep = "")
     },
     content = function(file) {
       write.csv(processed_data(), file, row.names = FALSE)