Update app.R

app.R

@@ -15,6 +15,10 @@ library(tidymodels)
 library(httr)
 library(ggforce)
 library(jsonlite)   # for parse_bat_tracking_json()
+library(readr)      # read_csv() for gzipped scrape downloads
+library(DT)         # data preview / retag / scrape tables
+library(shinyBS)    # bsModal pitch-edit dialog
+library(reticulate) # huggingface_hub upload in the Scraping tab
 
 PASSWORD <- Sys.getenv("password")
 
@@ -161,8 +165,69 @@ app_css <- "
   font-size: 1.2em;
   font-weight: bold;
 }
+
+  /* ---- ported data-processing styles ---- */
+/* 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;
+    }
+/* Catcher notes styling */
+    .catcher-notes-input-box {
+      background: linear-gradient(135deg, #e8f4f8 0%, #f0e6d3 100%);
+      border: 2px solid darkcyan;
+      border-radius: 15px;
+      padding: 20px;
+    }
+/* Download section styling */
+    .download-option-box {
+      background: linear-gradient(135deg, #e8f4f8 0%, #f0e6d3 100%);
+      border: 1px solid rgba(0,139,139,.2);
+      border-radius: 12px;
+      padding: 20px;
+      margin-bottom: 15px;
+    }
+.catcher-note-entry {
+      background: #fff;
+      border: 1px solid rgba(0,139,139,.15);
+      border-radius: 10px;
+      padding: 12px 16px;
+      margin-bottom: 8px;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+.catcher-note-entry:hover {
+      border-color: darkcyan;
+      box-shadow: 0 2px 8px rgba(0,139,139,.12);
+    }
+.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;
+    }
 "
 
+
+
+
 stuffplus_recipe <- readRDS("stuffplus_recipe.rds")
 
 stuffplus_model <- xgb.load("stuffplus_xgb.json")
@@ -5848,61 +5913,431 @@ app_ui <- fluidPage(
     ),
     tabPanel("Data Processing",
       br(),
-    fluidRow(
-          column(
-            4,
-            div(class = "main-panel",
-                div(class = "upload-box",
-                    h3("Process Raw TrackMan Data", style = "color: #006F71; margin-top: 0;"),
-                    p("Clean a raw TrackMan export (add result metrics, run values) and optionally append Stuff+, then download the processed dataset for use in the report tabs.",
-                      style = "font-size: 0.85em; color: #666;"),
-                    fileInput("proc_file", "Game Data (CSV or Parquet)",
-                              accept = c(".csv", "text/csv", ".parquet"),
-                              buttonLabel = "Choose File...", placeholder = "No file selected"),
-                    fileInput("proc_json", "Bat Tracking JSON (optional)",
-                              accept = c(".json", "application/json"),
-                              buttonLabel = "Choose JSON...", placeholder = "Optional - merged by PitchUID"),
-                    radioButtons("proc_date_format", "Date Format",
-                                 c("YYYY-MM-DD" = "yyyy", "M/D/YY" = "mdyy"),
-                                 selected = "yyyy", inline = TRUE),
-                    checkboxInput("proc_run_stuff", "Append Stuff+ predictions", value = TRUE),
-                    actionButton("proc_run", "Process Data", class = "btn-primary",
-                                 style = "margin-top: 10px;")
-                ),
-                br(),
-                div(class = "upload-box",
-                    h4("Columns to Remove", style = "color: #006F71; margin-top: 0;"),
-                    div(style = "margin-bottom: 8px;",
-                        actionButton("proc_cols_all",  "Select All",     class = "btn-secondary",
-                                     style = "width:auto; padding:4px 10px; font-size:12px; margin-right:4px;"),
-                        actionButton("proc_cols_none", "Clear",          class = "btn-secondary",
-                                     style = "width:auto; padding:4px 10px; font-size:12px; margin-right:4px;"),
-                        actionButton("proc_cols_spin", "Spin-Axis Only", class = "btn-secondary",
-                                     style = "width:auto; padding:4px 10px; font-size:12px;")
+        tabsetPanel(id = "proc_tabs",
+              
+                    # Upload & Process Tab
+                    tabPanel(
+                      "Upload & Process",
+                      fluidRow(
+                        column(6,
+                               h3("1. Upload TrackMan CSV or Parquet"),
+                               fileInput("file", "Choose CSV or Parquet File (max 5,000 rows)", 
+                                         accept = c(".csv", ".parquet")),
+                               fluidRow(
+                                 column(3,
+                                        checkboxInput("header", "Header", TRUE)
+                                 ),
+                                 column(3,
+                                        radioButtons("sep", "Separator",
+                                                     choices = c(Comma = ",", Semicolon = ";", Tab = "\t"),
+                                                     selected = ",", inline = TRUE)
+                                 ),
+                                 column(3,
+                                        radioButtons("quote", "Quote",
+                                                     choices = c(None = "", "Double Quote" = '"', "Single Quote" = "'"),
+                                                     selected = '"', inline = TRUE)
+                                 ),
+                                 column(3,
+                                        radioButtons("date_format", "Date Output Format",
+                                                     choices = c("YYYY-MM-DD" = "yyyy", "M/D/YY" = "mdyy"),
+                                                     selected = "yyyy")
+                                 )
+                               ),
+                               p(style = "color: #666; font-size: 12px;", 
+                                 "CSV options (Header, Separator, Quote) are ignored for Parquet files."),
+                               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("3. 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(),
+                               h4("Processing Summary"),
+                               verbatimTextOutput("process_summary")
+                        )
+                      )
                     ),
-                    div(style = "max-height: 220px; overflow-y: auto; font-size: 0.85em;",
-                        checkboxGroupInput("proc_drop_cols", NULL,
-                                           choices = columns_to_remove,
-                                           selected = columns_to_remove)
-                    )
-                ),
-                hr(),
-                uiOutput("proc_download_ui")
-            )
-          ),
-          column(
-            8,
-            div(class = "main-panel",
-                h3("Processed Data", style = "color: #006F71; margin-top: 0;"),
-                uiOutput("proc_status"),
-                verbatimTextOutput("proc_summary"),
-                br(),
-                h4("Preview (first 15 rows)", style = "color: #006F71;"),
-                div(style = "overflow-x: auto;",
-                    tableOutput("proc_preview")
+              
+                    # 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",
+                      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", "Sweeper", "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")
+                        )
+                      ),
+                
+                      # ── Rule-Based Pitch Retagging Panel ──
+                      hr(),
+                      fluidRow(
+                        column(12,
+                          div(
+                            style = "background: linear-gradient(135deg, #e8f4f8 0%, #f0e6d3 100%); border: 2px solid darkcyan; border-radius: 15px; padding: 20px; margin-top: 10px;",
+                            h3("Rule-Based Pitch Retagging", style = "margin-top: 0; color: darkcyan; border-bottom: 2px solid darkcyan; padding-bottom: 8px;"),
+                            p(style = "color: #666; font-size: 13px; margin-bottom: 15px;",
+                              "Set filters to match pitches, then retag them all at once. ",
+                              "Only pitches matching ALL non-empty filters for the selected pitcher will be changed."),
+
+                            fluidRow(
+                              # Column 1: Source pitch type + date range
+                              column(3,
+                                h4("Pitch Type & Date", style = "color: peru; margin-top: 0;"),
+                                selectInput("retag_from_type", "Current Pitch Type:",
+                                            choices = c("(Any)" = "", "Fastball", "Sinker", "Cutter",
+                                                        "Slider", "Curveball", "ChangeUp", "Splitter",
+                                                        "Knuckleball", "Sweeper", "Other"),
+                                            selected = ""),
+                                dateRangeInput("retag_dates", "Date Range (optional):",
+                                               start = NA, end = NA),
+                                textInput("retag_pitch_no_range", "Pitch Numbers (e.g. 1-50):", value = "")
+                              ),
+
+                              # Column 2: Velocity & spin filters
+                              column(3,
+                                h4("Velocity & Spin", style = "color: peru; margin-top: 0;"),
+                                fluidRow(
+                                  column(6, numericInput("retag_velo_min", "Velo Min:", value = NA)),
+                                  column(6, numericInput("retag_velo_max", "Velo Max:", value = NA))
+                                ),
+                                fluidRow(
+                                  column(6, numericInput("retag_spin_min", "Spin Min:", value = NA)),
+                                  column(6, numericInput("retag_spin_max", "Spin Max:", value = NA))
+                                )
+                              ),
+
+                              # Column 3: Movement filters
+                              column(3,
+                                h4("Movement (inches)", style = "color: peru; margin-top: 0;"),
+                                fluidRow(
+                                  column(6, numericInput("retag_ivb_min", "IVB Min:", value = NA)),
+                                  column(6, numericInput("retag_ivb_max", "IVB Max:", value = NA))
+                                ),
+                                fluidRow(
+                                  column(6, numericInput("retag_hb_min", "HB Min:", value = NA)),
+                                  column(6, numericInput("retag_hb_max", "HB Max:", value = NA))
+                                ),
+                                fluidRow(
+                                  column(6, numericInput("retag_vb_min", "VBreak Min:", value = NA)),
+                                  column(6, numericInput("retag_vb_max", "VBreak Max:", value = NA))
+                                )
+                              ),
+
+                              # Column 4: Target type + actions
+                              column(3,
+                                h4("Retag To", style = "color: peru; margin-top: 0;"),
+                                selectInput("retag_to_type", "New Pitch Type:",
+                                            choices = c("Fastball", "Sinker", "Cutter", "Slider",
+                                                        "Curveball", "ChangeUp", "Splitter",
+                                                        "Knuckleball", "Sweeper", "Other"),
+                                            selected = "Sweeper"),
+                                br(),
+                                actionButton("retag_preview_btn", "Preview Matches",
+                                             class = "btn-info", style = "width: 100%;"),
+                                br(), br(),
+                                actionButton("retag_apply_btn", "Apply Retag",
+                                             class = "btn-success", style = "width: 100%; font-weight: bold;"),
+                                br(), br(),
+                                actionButton("retag_clear_btn", "Clear Filters",
+                                             class = "btn-default", style = "width: 100%;")
+                              )
+                            ),
+
+                            # Preview results area
+                            div(
+                              style = "margin-top: 15px;",
+                              uiOutput("retag_preview_summary"),
+                              DT::dataTableOutput("retag_preview_table")
+                            )
+                          )
+                        )
+                      )
+                    ),
+              
+                    # ══════════════════════════════════════════════════════════════
+                    # Catcher Notes Tab
+                    # ══════════════════════════════════════════════════════════════
+                    tabPanel(
+                      "Catcher Notes",
+                      fluidRow(
+                        column(5,
+                          div(class = "catcher-notes-input-box",
+                            h3("Add Catcher Note", style = "margin-top: 0; color: darkcyan; border-bottom: 2px solid darkcyan; padding-bottom: 8px;"),
+                            p(style = "color: #666; font-size: 13px; margin-bottom: 15px;",
+                              "Log catcher events (throws, wild pitches, passed balls). ",
+                              "Each note is matched to the pitch row by Catcher, Batter, Inning, and Count, ",
+                              "then written into a CatcherNotes column on download."),
+                      
+                            fluidRow(
+                              column(6, selectInput("cn_catcher", "Catcher:", choices = NULL)),
+                              column(6, selectInput("cn_batter", "Batter:", choices = NULL))
+                            ),
+                      
+                            fluidRow(
+                              column(4, numericInput("cn_inning", "Inning:", value = 1, min = 1, max = 20, step = 1)),
+                              column(4, numericInput("cn_balls", "Balls:", value = 0, min = 0, max = 3, step = 1)),
+                              column(4, numericInput("cn_strikes", "Strikes:", value = 0, min = 0, max = 2, step = 1))
+                            ),
+                      
+                            selectInput("cn_result", "Result:",
+                                        choices = c("2B Out", "2B Safe", "3B Out", "3B Safe",
+                                                    "Wild Pitch", "Passed Ball",
+                                                    "Pickoff Attempt", "Pickoff Out",
+                                                    "Blocked Ball", "Other"),
+                                        selected = "2B Out"),
+                      
+                            conditionalPanel(
+                              condition = "input.cn_result == 'Other'",
+                              textInput("cn_custom_result", "Custom Note:", placeholder = "Describe the event...")
+                            ),
+                      
+                            br(),
+                            actionButton("cn_add_btn", "Add Note", class = "btn-success", 
+                                         style = "width: 100%; font-weight: bold; font-size: 15px;"),
+                            br(), br(),
+                            uiOutput("cn_match_feedback")
+                          )
+                        ),
+                  
+                        column(7,
+                          h3("Logged Catcher Notes"),
+                          p(style = "color: #666; font-size: 13px;",
+                            "These notes will be merged into the CatcherNotes column when you download the data."),
+                          DT::dataTableOutput("cn_notes_table"),
+                          br(),
+                          fluidRow(
+                            column(6,
+                              actionButton("cn_clear_all_btn", "Clear All Notes", class = "btn-danger",
+                                           style = "width: 100%;")
+                            ),
+                            column(6,
+                              verbatimTextOutput("cn_summary")
+                            )
+                          )
+                        )
+                      )
+                    ),
+              
+                    tabPanel(
+                      "Download",
+                      fluidRow(
+                        column(12,
+                               h3("Download Processed Data"),
+                         
+                               div(class = "download-option-box",
+                                 h4("Processing Mode", style = "color: darkcyan; margin-top: 0;"),
+                                 radioButtons("download_mode", NULL,
+                                              choices = c(
+                                                "Raw Edited CSV (as-is)" = "raw",
+                                                "Full Processing (clean + indicators + Stuff+)" = "full"
+                                              ),
+                                              selected = "raw", inline = TRUE),
+                                 conditionalPanel(
+                                   condition = "input.download_mode == 'full'",
+                                   div(style = "background: #d4edda; border-left: 4px solid #28a745; padding: 12px; border-radius: 0 8px 8px 0; margin: 10px 0;",
+                                     p(style = "margin: 0; color: #155724; font-size: 13px;",
+                                       tags$b("Full Processing will:"), 
+                                       "Normalize names & pitch types, convert PlateLocHeight/Side to inches, ",
+                                       "add swing/whiff/chase/zone flags, compute wOBA/SLG/OBP indicators, ",
+                                       "join run values, predict Stuff+, and trim to ~140 columns.")
+                                   )
+                                 ),
+                                 conditionalPanel(
+                                   condition = "input.download_mode == 'raw'",
+                                   div(style = "background: #e8f4f8; border-left: 4px solid darkcyan; padding: 12px; border-radius: 0 8px 8px 0; margin: 10px 0;",
+                                     p(style = "margin: 0; color: #006F71; font-size: 13px;",
+                                       tags$b("Raw Edited:"), 
+                                       "Downloads your current data with any pitch retags, column removals, ",
+                                       "bat tracking merges, and catcher notes applied — no additional processing.")
+                                   )
+                                 ),
+                                 hr(),
+                                 fluidRow(
+                                   column(5,
+                                          textInput("download_filename", "File Name (without extension):",
+                                                    value = paste0("app_ready_COA_", Sys.Date()))
+                                   ),
+                                   column(3,
+                                          radioButtons("download_format", "Export Format:",
+                                                       choices = c("CSV" = "csv", "Parquet" = "parquet"),
+                                                       selected = "csv", inline = TRUE)
+                                   ),
+                                   hr(),
+      radioButtons("download_team_filter", "Team Filter:",
+                   choices = c(
+                     "All Data" = "all",
+                     "Coastal Pitchers Only (PitcherTeam = COA_CHA)" = "coastal_pitchers",
+                     "Coastal Hitters Only (BatterTeam = COA_CHA)" = "coastal_hitters"
+                   ),
+                   selected = "all"),
+      hr(),
+                                   column(4,
+                                          br(),
+                                          downloadButton("downloadData", "Download", class = "btn-success btn-lg")
+                                   )
+                                 )
+                               ),
+                         
+                               br(),
+                               h4("Data Summary:"),
+                               verbatimTextOutput("data_summary")
+                        )
+                      )
+                    ),
+                      #Scrape Tab
+                      tabPanel(
+                        "Scraping",
+                        fluidRow(
+                          column(2,
+                            h4("Data Source", style = "color: darkcyan; border-bottom: 2px solid darkcyan; padding-bottom: 6px;"),
+                            radioButtons("scrape_source", NULL,
+                                         choices = c("TrackMan PBP" = "pbp",
+                                                     "TrackMan Positional" = "pos",
+                                                     "NCAA Scoreboard" = "ncaa"),
+                                         selected = "pbp")
+                          ),
+                    
+                          column(4,
+                            h3("Controls"),
+                    
+                            dateInput("start_date", "Start Date:", value = Sys.Date() - 1),
+                            dateInput("end_date", "End Date:", value = Sys.Date() - 1),
+                      
+                            uiOutput("scrape_options"),
+                      
+                            br(),
+                            actionButton("scrape_btn", "Scrape Data", class = "btn-primary"),
+                            br(), br(),
+                            downloadButton("download_scrape", "Download CSV"),
+                            actionButton("upload_hf_btn", "Upload to HF Dataset", class = "btn-download")
+                          ),
+                    
+                          column(6,
+                            h3("Progress"),
+                            verbatimTextOutput("scrape_status"),
+                            hr(),
+                            h3("Data Preview"),
+                            DT::dataTableOutput("scrape_preview")
+                          )
+                        )
+                      )
+        ),,
+        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", "Sweeper", "Other"),
+                                selected = "Fastball"),
+                    br(),
+                    actionButton("update_pitch", "Update Pitch Type", class = "btn-primary btn-lg"),
+                    actionButton("cancel_edit", "Cancel", class = "btn-default")
                 )
-            )
-          )
         )
     )
   )
@@ -6948,127 +7383,1648 @@ server <- function(input, output, session) {
     contentType = "application/zip"
   )
 
-  # ===================== DATA PROCESSING TAB =====================
-  proc_result <- reactiveVal(NULL)
 
-  # Column-selection helper buttons
-  observeEvent(input$proc_cols_all, {
-    updateCheckboxGroupInput(session, "proc_drop_cols", selected = columns_to_remove)
+
+  # ===== ported data-processing / scraping / retag server logic =====
+  uploaded_file_type <- reactiveVal("csv")
+  
+  # Reactive values
+  processed_data <- reactiveVal(NULL)
+  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)
+  scraped_data <- reactiveVal(NULL)
+  scrape_polling <- reactiveVal(FALSE)
+  scrape_status_msg <- reactiveVal("Ready.")
+  
+  # Catcher Notes: stored as a list of data frames, each row is one note
+  catcher_notes_list <- reactiveVal(data.frame(
+    NoteID      = integer(0),
+    Catcher     = character(0),
+    Batter      = character(0),
+    Inning      = integer(0),
+    Balls       = integer(0),
+    Strikes     = integer(0),
+    Result      = character(0),
+    MatchedRow  = integer(0),
+    stringsAsFactors = FALSE
+  ))
+  
+  # Handle column selection buttons
+  observeEvent(input$select_all_cols, {
+    updateCheckboxGroupInput(session, "columns_to_remove", 
+                             selected = columns_to_remove)
   })
-  observeEvent(input$proc_cols_none, {
-    updateCheckboxGroupInput(session, "proc_drop_cols", selected = character(0))
+  
+  observeEvent(input$deselect_all_cols, {
+    updateCheckboxGroupInput(session, "columns_to_remove", selected = character(0))
   })
-  observeEvent(input$proc_cols_spin, {
-    spin_cols <- columns_to_remove[grepl("SpinAxis3d", columns_to_remove)]
-    updateCheckboxGroupInput(session, "proc_drop_cols", selected = spin_cols)
+  
+  observeEvent(input$select_spinaxis, {
+    spinaxis_cols <- columns_to_remove[grepl("SpinAxis3d", columns_to_remove)]
+    updateCheckboxGroupInput(session, "columns_to_remove", selected = spinaxis_cols)
   })
-
-  # Run the pipeline
-  observeEvent(input$proc_run, {
-    if (is.null(input$proc_file)) {
-      showNotification("Please choose a CSV or Parquet file first.", type = "warning", duration = 5)
-      return(NULL)
+  
+  # Shared helper: process raw data into processed_data / plot_data
+  run_processing <- function(df) {
+    # Merge bat tracking if available
+    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
     }
-    json_path <- if (!is.null(input$proc_json)) input$proc_json$datapath else NULL
-
-    withProgress(message = "Processing data...", value = 0, {
-      result <- tryCatch({
-        incProgress(0.2, detail = "Reading and cleaning")
-        df <- process_uploaded_trackman(
-          filepath      = input$proc_file$datapath,
-          filename      = input$proc_file$name,
-          json_path     = json_path,
-          drop_columns  = input$proc_drop_cols %||% character(0),
-          date_format   = input$proc_date_format,
-          run_stuffplus = isTRUE(input$proc_run_stuff)
-        )
-        incProgress(0.7, detail = "Finalizing")
-        df
-      }, error = function(e) {
-        showNotification(paste("Processing error:", e$message), type = "error", duration = 10)
-        NULL
-      })
-      proc_result(result)
+    
+    selected_cols_to_remove <- input$columns_to_remove %||% character(0)
+    processed_df <- df
+    
+    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))
+      }
+    }
+    
+    processed_df <- processed_df %>% distinct()
+    
+    processed_data(processed_df)
+    plot_data(processed_df)
+    
+    # Update catcher notes dropdowns
+    update_catcher_note_choices(processed_df)
+    
+    return(processed_df)
+  }
+  
+  # Helper to populate Catcher Notes dropdowns from current data
+  update_catcher_note_choices <- function(df) {
+    if (!is.null(df)) {
+      if ("Catcher" %in% names(df)) {
+        catchers <- sort(unique(df$Catcher[!is.na(df$Catcher) & df$Catcher != ""]))
+        updateSelectInput(session, "cn_catcher", choices = catchers,
+                          selected = if (length(catchers) > 0) catchers[1] else NULL)
+      }
+      if ("Batter" %in% names(df)) {
+        batters <- sort(unique(df$Batter[!is.na(df$Batter) & df$Batter != ""]))
+        updateSelectInput(session, "cn_batter", choices = batters,
+                          selected = if (length(batters) > 0) batters[1] else NULL)
+      }
+    }
+  }
+  
+  # Re-process data when date format changes
+  observeEvent(input$date_format, {
+    req(input$file)
+    
+    tryCatch({
+      df <- read_uploaded_file(input$file$datapath, input$file$name,
+                               input$header, input$sep, input$quote)
+      
+      df <- convert_date_columns(df, input$date_format)
+      csv_data_raw(df)
+      run_processing(df)
+      
+      showNotification(
+        paste("Date format updated to:", if (input$date_format == "mdyy") "M/D/YY" else "YYYY-MM-DD"),
+        type = "message", duration = 3
+      )
+      
+    }, error = function(e) {
+      showNotification(paste("Error updating date format:", e$message), type = "error")
     })
-
-    if (!is.null(proc_result())) {
+  }, ignoreInit = TRUE)
+  
+  # Process uploaded file (CSV or Parquet)
+  observeEvent(input$file, {
+    req(input$file)
+    
+    tryCatch({
+      ext <- tolower(tools::file_ext(input$file$name))
+      uploaded_file_type(ext)
+      
+      df <- read_uploaded_file(input$file$datapath, input$file$name,
+                               input$header, input$sep, input$quote)
+      
+      df <- convert_date_columns(df, input$date_format)
+      csv_data_raw(df)
+      
+      processed_df <- run_processing(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])
+      }
+      
+      # Auto-populate download filename from uploaded file
+      base_name <- tools::file_path_sans_ext(input$file$name)
+      updateTextInput(session, "download_filename", value = paste0(base_name, "_processed"))
+      
+      format_label <- if (ext == "parquet") "Parquet" else "CSV"
       showNotification(
-        paste0("Processed ", format(nrow(proc_result()), big.mark = ","),
-               " rows x ", ncol(proc_result()), " columns."),
-        type = "message", duration = 4
+        paste0(format_label, " loaded: ", nrow(df), " rows x ", ncol(df), " columns"),
+        type = "message", duration = 3
       )
+      
+    }, error = function(e) {
+      showNotification(paste("Error processing file:", 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 (!is.null(csv_data_raw()) && parsed$success && !is.null(parsed$data)) {
+        result <- merge_with_bat_tracking(csv_data_raw(), parsed$data)
+        merge_result(result)
+        
+        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/Parquet status output
+  output$csv_status <- renderText({
+    if (is.null(input$file)) {
+      return("No file uploaded yet. Accepts CSV or Parquet (max 5,000 rows).")
+    }
+    
+    if (is.null(csv_data_raw())) {
+      return("Processing file...")
     }
+    
+    df <- csv_data_raw()
+    ext <- uploaded_file_type()
+    format_label <- if (ext == "parquet") "Parquet" else "CSV"
+    game_id <- if ("GameID" %in% names(df)) unique(df$GameID)[1] else "Unknown"
+    date_fmt <- if (input$date_format == "mdyy") "M/D/YY" else "YYYY-MM-DD"
+    
+    paste(
+      paste0("\u2713 ", format_label, " loaded successfully!"),
+      paste("  Game ID:", game_id),
+      paste("  Rows:", nrow(df)),
+      paste("  Columns:", ncol(df)),
+      paste("\u2713 Date format:", date_fmt),
+      sep = "\n"
+    )
   })
-
-  output$proc_status <- renderUI({
-    if (is.null(proc_result())) {
-      div(style = "color:#888; font-style:italic;",
-          "Upload a raw TrackMan file and click Process Data to begin.")
+  
+  # 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("\u2717", parsed$message))
+    }
+    
+    paste(
+      "\u2713 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)) {
+      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("\u26A0 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)
+      ))
+    }
+    
+    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("\u2713 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;", "\u26A0 Note: Game IDs differ but PitchUIDs matched")
+      )
+    } else {
+      div(class = "merge-status-box merge-warning",
+          h4("\u26A0 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.")
+      ))
+    }
+    
+    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)
+    }
+    
+    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 {
-      div(style = "color:#006F71; font-weight:bold;", "Processing complete.")
+      return(NULL)
     }
   })
-
-  output$proc_summary <- renderPrint({
-    df <- proc_result()
-    if (is.null(df)) return(invisible(NULL))
-    has_stuff <- "stuff_plus" %in% names(df)
-    has_bat   <- "BatSpeed_Sensor" %in% names(df)
-    cat("Rows:        ", format(nrow(df), big.mark = ","), "\n", sep = "")
-    cat("Columns:     ", ncol(df), "\n", sep = "")
-    cat("Stuff+ added:", if (has_stuff) " yes" else " no", "\n", sep = "")
-    if (has_stuff) {
-      sp <- suppressWarnings(round(mean(df$stuff_plus, na.rm = TRUE), 1))
-      cat("Mean Stuff+: ", sp, "\n", sep = "")
+  
+  # Processing summary
+  output$process_summary <- renderText({
+    if (is.null(input$file)) {
+      return("No file uploaded yet.")
     }
-    if (has_bat) {
-      matched <- sum(!is.na(df$BatSpeed_Sensor))
-      cat("Bat-tracking matched:", matched, "\n", sep = " ")
+    
+    if (is.null(processed_data())) {
+      return("Processing...")
+    }
+    
+    df <- processed_data()
+    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()
+    ext <- uploaded_file_type()
+    format_label <- if (ext == "parquet") "Parquet" else "CSV"
+    
+    removed_cols_text <- if (length(removed_cols) > 0) {
+      paste("\u2713 Removed columns:", length(removed_cols))
+    } else {
+      "\u2713 Removed columns: 0"
+    }
+    
+    bat_tracking_text <- if (!is.null(result) && result$matched > 0) {
+      paste("\u2713 Bat tracking merged:", result$matched, "pitches")
+    } else if (!is.null(bat_tracking_parsed())) {
+      "\u26A0 Bat tracking: No matches"
+    } else {
+      "\u25CB Bat tracking: Not uploaded"
     }
+    
+    notes <- catcher_notes_list()
+    notes_text <- if (nrow(notes) > 0) {
+      paste("\u2713 Catcher notes:", nrow(notes), "logged")
+    } else {
+      "\u25CB Catcher notes: None"
+    }
+    
+    summary_text <- paste(
+      paste0("\u2713 ", format_label, " file processed successfully!"),
+      paste("\u2713 Original columns:", ncol(original_df)),
+      paste("\u2713 Final columns:", ncol(df)),
+      paste("\u2713 Rows processed:", nrow(df)),
+      removed_cols_text,
+      bat_tracking_text,
+      notes_text,
+      "\u2713 Duplicates removed",
+      paste("\u2713 Date format:", if (input$date_format == "mdyy") "M/D/YY" else "YYYY-MM-DD"),
+      sep = "\n"
+    )
+    
+    return(summary_text)
   })
-
-  output$proc_preview <- renderTable({
-    df <- proc_result()
-    if (is.null(df)) return(NULL)
-    pref <- c("Date", "Pitcher", "Batter", "TaggedPitchType", "PitchCall",
-              "PlayResult", "RelSpeed", "SpinRate", "stuff_plus", "woba")
-    cols <- intersect(pref, names(df))
-    if (length(cols) == 0) cols <- names(df)[seq_len(min(10, ncol(df)))]
-    head(df[, cols, drop = FALSE], 15)
-  }, striped = TRUE, hover = TRUE, bordered = TRUE, spacing = "xs", digits = 2, na = "")
-
-  output$proc_download_ui <- renderUI({
-    if (is.null(proc_result())) return(NULL)
-    tagList(
-      downloadButton("proc_download_csv", "Download Processed CSV", class = "btn-primary"),
-      br(), br(),
-      downloadButton("proc_download_parquet", "Download Processed Parquet", class = "btn-secondary")
+  
+  # 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()
+    }
+    
+    pitcher_data$color <- pitch_colors[pitcher_data$TaggedPitchType]
+    pitcher_data$color[is.na(pitcher_data$color)] <- "#D3D3D3"
+    
+    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))
+    
+    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)
+    
+    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)
+    }
+    
+    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)
+    }
+    
+    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)
+    
+    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()
+    
+    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)
+    
+    if (min(distances) <= 2) {
+      clicked_pitch <- pitcher_data[closest_idx, ]
+      
+      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
+      ))
+      
+      updateSelectInput(session, "modal_new_pitch_type", 
+                        selected = clicked_pitch$TaggedPitchType)
+      
+      showModal(modalDialog(
+        title = "Edit Pitch Type",
+        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", "Sweeper","Other"),
+                        selected = clicked_pitch$TaggedPitchType),
+            br(),
+            actionButton("update_pitch", "Update Pitch Type", class = "btn-primary btn-lg"),
+            actionButton("cancel_edit", "Cancel", class = "btn-default")
+        ),
+        footer = NULL,
+        size = "m",
+        easyClose = TRUE
+      ))
+    }
+  })
+  
+  # Handle brush selection (drag mode)
+  observeEvent(input$plot_brush, {
+    req(plot_data(), input$pitcher_select, input$plot_brush)
+    
+    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()
+    
+    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()
+    }
+    
+    current_data <- plot_data()
+    
+    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
+        ))
+    }
+    
+    plot_data(current_data)
+    processed_data(current_data)
+    selected_points(NULL)
+    
+    showNotification(
+      paste("Updated", nrow(sel_points), "pitches to", input$bulk_pitch_type), 
+      type = "message", duration = 3
     )
   })
-
-  output$proc_download_csv <- downloadHandler(
-    filename = function() {
-      base <- if (!is.null(input$proc_file)) tools::file_path_sans_ext(input$proc_file$name) else "trackman"
-      paste0(base, "_processed.csv")
-    },
-    content = function(file) {
-      df <- proc_result(); req(df)
-      write.csv(df, file, row.names = FALSE, na = "")
+  
+  # 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."
     }
-  )
-
-  output$proc_download_parquet <- downloadHandler(
-    filename = function() {
-      base <- if (!is.null(input$proc_file)) tools::file_path_sans_ext(input$proc_file$name) else "trackman"
-      paste0(base, "_processed.parquet")
-    },
-    content = function(file) {
-      df <- proc_result(); req(df)
-      arrow::write_parquet(df, file)
+  })
+  
+  # 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, ]
+      
+      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 {
+      ""
     }
-  )
-  # =================== END DATA PROCESSING TAB ===================
-
+  })
+  
+  # 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
+        ),
+        in_zone = ifelse("StrikeZoneIndicator" %in% names(.), StrikeZoneIndicator, 
+                        ifelse(!is.na(PlateLocSide) & !is.na(PlateLocHeight) & 
+                                 PlateLocSide >= -0.95 & PlateLocSide <= 0.95 &
+                                 PlateLocHeight >= 1.6 & PlateLocHeight <= 3.5, 1, 0)),
+        is_whiff = ifelse("WhiffIndicator" %in% names(.), WhiffIndicator,
+                         ifelse(!is.na(PitchCall) & PitchCall == "StrikeSwinging", 1, 0)),
+        chase = ifelse("Chaseindicator" %in% names(.), Chaseindicator,
+                      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))
+      )
+    
+    total_pitches <- nrow(movement_stats)
+    
+    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),
+        `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", mean(SpinRate, na.rm = TRUE)),
+                           "\u2014"),
+        `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 "\u2014"
+        } else "\u2014",
+        `Zone%` = sprintf("%.1f%%", round(mean(in_zone, na.rm = TRUE) * 100, 1)),
+        `Whiff%` = sprintf("%.1f%%", round(mean(is_whiff, 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_lines <- c(
+        paste("Pitcher:", pitch_info$pitcher),
+        if ("PitchNo" %in% names(pitch_data) && !is.na(pitch_data$PitchNo)) paste("Pitch No:", pitch_data$PitchNo) else NULL,
+        if ("Batter" %in% names(pitch_data) && !is.na(pitch_data$Batter)) paste("Batter:", pitch_data$Batter) else NULL,
+        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)) {
+        info_lines <- c(info_lines, paste("Spin Rate:", round(pitch_data$SpinRate, 0), "rpm"))
+      }
+      
+      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), "\u00B0"),
+                        paste("Horizontal Attack Angle:", round(pitch_data$HorizontalAttackAngle_Sensor, 1), "\u00B0"))
+      }
+      
+      if ("Date" %in% names(pitch_data) && !is.na(pitch_data$Date)) {
+        info_lines <- c(info_lines, paste("Date:", pitch_data$Date))
+      }
+      
+      return(paste(info_lines, collapse = "\n"))
+    } else {
+      return("No pitch selected")
+    }
+  })
+  
+  # Update pitch type
+  observeEvent(input$update_pitch, {
+    pitch_info <- selected_pitch()
+    
+    if (!is.null(pitch_info)) {
+      current_data <- plot_data()
+      
+      target_pitcher <- pitch_info$pitcher
+      target_hb <- pitch_info$data$HorzBreak
+      target_ivb <- pitch_info$data$InducedVertBreak
+      target_velo <- pitch_info$data$RelSpeed
+      
+      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
+        ))
+      
+      plot_data(current_data)
+      processed_data(current_data)
+      
+      removeModal()
+      
+      showNotification(
+        paste("Updated pitch from", pitch_info$original_type, "to", input$modal_new_pitch_type), 
+        type = "message", duration = 3
+      )
+      
+      selected_pitch(NULL)
+    }
+  })
+  
+  # Cancel edit
+  observeEvent(input$cancel_edit, {
+    removeModal()
+    selected_pitch(NULL)
+  })
+  
+  # ══════════════════════════════════════════════════════════════
+  # Rule-Based Pitch Retagging — Server Logic
+  # ══════════════════════════════════════════════════════════════
+
+  # Reactive: compute the set of pitches matching all active filters
+  retag_matched <- reactive({
+    req(plot_data(), input$pitcher_select)
+
+    df <- plot_data() %>%
+      filter(Pitcher == input$pitcher_select)
+
+    # Filter: Current pitch type
+    if (!is.null(input$retag_from_type) && input$retag_from_type != "") {
+      df <- df %>% filter(TaggedPitchType == input$retag_from_type)
+    }
+
+    # Filter: Date range
+    if ("Date" %in% names(df)) {
+      d_start <- input$retag_dates[1]
+      d_end   <- input$retag_dates[2]
+      if (!is.na(d_start) && !is.na(d_end)) {
+        df <- df %>%
+          filter(!is.na(Date)) %>%
+          mutate(.tmp_date = as.Date(Date)) %>%
+          filter(.tmp_date >= as.Date(d_start), .tmp_date <= as.Date(d_end)) %>%
+          select(-.tmp_date)
+      }
+    }
+
+    # Filter: Pitch number range (supports "1-50" or single number)
+    if (!is.null(input$retag_pitch_no_range) && nzchar(trimws(input$retag_pitch_no_range))) {
+      pn_text <- trimws(input$retag_pitch_no_range)
+      if (grepl("^\\d+-\\d+$", pn_text)) {
+        parts <- as.numeric(strsplit(pn_text, "-")[[1]])
+        if ("PitchNo" %in% names(df)) {
+          df <- df %>% filter(!is.na(PitchNo), PitchNo >= parts[1], PitchNo <= parts[2])
+        }
+      } else if (grepl("^\\d+$", pn_text)) {
+        if ("PitchNo" %in% names(df)) {
+          df <- df %>% filter(PitchNo == as.numeric(pn_text))
+        }
+      }
+    }
+
+    # Filter: Velocity
+    if (!is.na(input$retag_velo_min)) df <- df %>% filter(!is.na(RelSpeed), RelSpeed >= input$retag_velo_min)
+    if (!is.na(input$retag_velo_max)) df <- df %>% filter(!is.na(RelSpeed), RelSpeed <= input$retag_velo_max)
+
+    # Filter: Spin Rate
+    if ("SpinRate" %in% names(df)) {
+      if (!is.na(input$retag_spin_min)) df <- df %>% filter(!is.na(SpinRate), SpinRate >= input$retag_spin_min)
+      if (!is.na(input$retag_spin_max)) df <- df %>% filter(!is.na(SpinRate), SpinRate <= input$retag_spin_max)
+    }
+
+    # Filter: Induced Vertical Break
+    if (!is.na(input$retag_ivb_min)) df <- df %>% filter(!is.na(InducedVertBreak), InducedVertBreak >= input$retag_ivb_min)
+    if (!is.na(input$retag_ivb_max)) df <- df %>% filter(!is.na(InducedVertBreak), InducedVertBreak <= input$retag_ivb_max)
+
+    # Filter: Horizontal Break
+    if (!is.na(input$retag_hb_min)) df <- df %>% filter(!is.na(HorzBreak), HorzBreak >= input$retag_hb_min)
+    if (!is.na(input$retag_hb_max)) df <- df %>% filter(!is.na(HorzBreak), HorzBreak <= input$retag_hb_max)
+
+    # Filter: Vertical Break
+    if ("VertBreak" %in% names(df)) {
+      if (!is.na(input$retag_vb_min)) df <- df %>% filter(!is.na(VertBreak), VertBreak >= input$retag_vb_min)
+      if (!is.na(input$retag_vb_max)) df <- df %>% filter(!is.na(VertBreak), VertBreak <= input$retag_vb_max)
+    }
+
+    df
+  })
+
+  # Preview button: show what would be retagged
+  observeEvent(input$retag_preview_btn, {
+    matched <- retag_matched()
+
+    output$retag_preview_summary <- renderUI({
+      n <- nrow(matched)
+      if (n == 0) {
+        div(class = "merge-status-box merge-warning",
+            style = "margin-bottom: 10px;",
+            p(style = "margin: 0; font-weight: 600; color: #856404;",
+              paste0("No pitches match these filters for ", input$pitcher_select, ".")))
+      } else {
+        type_counts <- table(matched$TaggedPitchType)
+        type_str <- paste(names(type_counts), "(", type_counts, ")", collapse = ", ")
+        div(class = "merge-status-box merge-success",
+            style = "margin-bottom: 10px;",
+            p(style = "margin: 0; font-weight: 600; color: #155724;",
+              paste0(n, " pitches matched \u2014 will retag to ", input$retag_to_type)),
+            p(style = "margin: 4px 0 0 0; color: #155724; font-size: 13px;", type_str))
+      }
+    })
+
+    output$retag_preview_table <- DT::renderDataTable({
+      if (nrow(matched) == 0) return(NULL)
+
+      preview_cols <- intersect(
+        c("PitchNo", "Date", "Batter", "TaggedPitchType", "RelSpeed",
+          "SpinRate", "InducedVertBreak", "HorzBreak", "VertBreak",
+          "PlateLocSide", "PlateLocHeight", "PitchCall"),
+        names(matched)
+      )
+
+      DT::datatable(
+        matched %>% select(all_of(preview_cols)),
+        options = list(scrollX = TRUE, pageLength = 8, dom = "tip"),
+        rownames = FALSE
+      ) %>%
+        DT::formatRound(
+          columns = intersect(preview_cols, c("RelSpeed", "InducedVertBreak", "HorzBreak", "VertBreak")),
+          digits = 1
+        )
+    })
+  })
+
+  # Apply retag: actually change TaggedPitchType
+  observeEvent(input$retag_apply_btn, {
+    matched <- retag_matched()
+
+    if (nrow(matched) == 0) {
+      showNotification("No pitches match the current filters.", type = "warning")
+      return()
+    }
+
+    current_data <- plot_data()
+
+    # Build composite key from available columns to uniquely identify pitches
+    key_cols <- intersect(c("PitchUID", "PitchNo", "Date", "Pitcher", "RelSpeed",
+                            "HorzBreak", "InducedVertBreak"), names(current_data))
+
+    make_key <- function(df) {
+      do.call(paste, c(df[key_cols], sep = "||"))
+    }
+
+    matched_keys <- make_key(matched)
+
+    current_data <- current_data %>%
+      mutate(.retag_key = make_key(cur_data())) %>%
+      mutate(TaggedPitchType = ifelse(
+        .retag_key %in% matched_keys & Pitcher == input$pitcher_select,
+        input$retag_to_type,
+        TaggedPitchType
+      )) %>%
+      select(-.retag_key)
+
+    plot_data(current_data)
+    processed_data(current_data)
+
+    n_matched <- nrow(matched)
+    showNotification(
+      paste0("Retagged ", n_matched, " pitches to ", input$retag_to_type),
+      type = "message", duration = 4
+    )
+
+    # Update preview to show completion
+    output$retag_preview_summary <- renderUI({
+      div(class = "merge-status-box merge-success",
+          style = "margin-bottom: 10px;",
+          p(style = "margin: 0; font-weight: 600; color: #155724;",
+            paste0("\u2713 Done! ", n_matched, " pitches retagged to ", input$retag_to_type, ".")))
+    })
+    output$retag_preview_table <- DT::renderDataTable({ NULL })
+  })
+
+  # Clear all retag filters
+  observeEvent(input$retag_clear_btn, {
+    updateSelectInput(session, "retag_from_type", selected = "")
+    updateDateRangeInput(session, "retag_dates", start = NA, end = NA)
+    updateTextInput(session, "retag_pitch_no_range", value = "")
+    updateNumericInput(session, "retag_velo_min", value = NA)
+    updateNumericInput(session, "retag_velo_max", value = NA)
+    updateNumericInput(session, "retag_spin_min", value = NA)
+    updateNumericInput(session, "retag_spin_max", value = NA)
+    updateNumericInput(session, "retag_ivb_min", value = NA)
+    updateNumericInput(session, "retag_ivb_max", value = NA)
+    updateNumericInput(session, "retag_hb_min", value = NA)
+    updateNumericInput(session, "retag_hb_max", value = NA)
+    updateNumericInput(session, "retag_vb_min", value = NA)
+    updateNumericInput(session, "retag_vb_max", value = NA)
+
+    output$retag_preview_summary <- renderUI({ NULL })
+    output$retag_preview_table <- DT::renderDataTable({ NULL })
+  })
+
+  # ══════════════════════════════════════════════════════════════
+  # End Rule-Based Retagging
+  # ══════════════════════════════════════════════════════════════
+  
+  # ══════════════════════════════════════════════════════════════
+  # Catcher Notes — Server Logic
+  # ══════════════════════════════════════════════════════════════
+  
+  # Add a catcher note
+  observeEvent(input$cn_add_btn, {
+    req(processed_data(), input$cn_catcher, input$cn_batter)
+    
+    df <- processed_data()
+    
+    # Determine the result text
+    result_text <- input$cn_result
+    if (result_text == "Other" && !is.null(input$cn_custom_result) && nzchar(trimws(input$cn_custom_result))) {
+      result_text <- trimws(input$cn_custom_result)
+    }
+    
+    # Find the matching row(s): Catcher + Batter + Inning + Balls + Strikes
+    # We match the LAST pitch in that count for that matchup in that inning
+    # (the event most likely happened on the final pitch of that count)
+    has_catcher <- "Catcher" %in% names(df)
+    has_batter  <- "Batter" %in% names(df)
+    has_inning  <- "Inning" %in% names(df)
+    has_balls   <- "Balls" %in% names(df)
+    has_strikes <- "Strikes" %in% names(df)
+    
+    candidates <- df
+    if (has_catcher) candidates <- candidates %>% filter(Catcher == input$cn_catcher)
+    if (has_batter)  candidates <- candidates %>% filter(Batter == input$cn_batter)
+    if (has_inning)  candidates <- candidates %>% filter(Inning == input$cn_inning)
+    if (has_balls)   candidates <- candidates %>% filter(Balls == input$cn_balls)
+    if (has_strikes) candidates <- candidates %>% filter(Strikes == input$cn_strikes)
+    
+    # Get the row index in the full dataframe for the last matching pitch
+    if (nrow(candidates) > 0) {
+      # Find which rows in the full df match
+      match_idx <- which(
+        (if (has_catcher) df$Catcher == input$cn_catcher else TRUE) &
+        (if (has_batter)  df$Batter == input$cn_batter else TRUE) &
+        (if (has_inning)  df$Inning == input$cn_inning else TRUE) &
+        (if (has_balls)   df$Balls == input$cn_balls else TRUE) &
+        (if (has_strikes) df$Strikes == input$cn_strikes else TRUE)
+      )
+      matched_row <- max(match_idx)  # last pitch at that count
+    } else {
+      matched_row <- NA_integer_
+    }
+    
+    # Build the new note
+    notes <- catcher_notes_list()
+    new_id <- if (nrow(notes) == 0) 1L else max(notes$NoteID) + 1L
+    
+    new_note <- data.frame(
+      NoteID     = new_id,
+      Catcher    = input$cn_catcher,
+      Batter     = input$cn_batter,
+      Inning     = as.integer(input$cn_inning),
+      Balls      = as.integer(input$cn_balls),
+      Strikes    = as.integer(input$cn_strikes),
+      Result     = result_text,
+      MatchedRow = matched_row,
+      stringsAsFactors = FALSE
+    )
+    
+    catcher_notes_list(bind_rows(notes, new_note))
+    
+    # Show match feedback
+    output$cn_match_feedback <- renderUI({
+      if (!is.na(matched_row)) {
+        pitch_info <- df[matched_row, ]
+        detail_parts <- c()
+        if ("PitchNo" %in% names(pitch_info) && !is.na(pitch_info$PitchNo)) 
+          detail_parts <- c(detail_parts, paste("Pitch #", pitch_info$PitchNo))
+        if ("PitchCall" %in% names(pitch_info) && !is.na(pitch_info$PitchCall))
+          detail_parts <- c(detail_parts, pitch_info$PitchCall)
+        if ("Pitcher" %in% names(pitch_info) && !is.na(pitch_info$Pitcher))
+          detail_parts <- c(detail_parts, paste("vs", pitch_info$Pitcher))
+        
+        div(class = "merge-status-box merge-success",
+            style = "margin-top: 10px;",
+            p(style = "margin: 0; font-weight: 600; color: #155724;",
+              paste0("\u2713 Matched to row ", matched_row)),
+            if (length(detail_parts) > 0) 
+              p(style = "margin: 4px 0 0 0; color: #155724; font-size: 13px;",
+                paste(detail_parts, collapse = " | "))
+        )
+      } else {
+        div(class = "merge-status-box merge-warning",
+            style = "margin-top: 10px;",
+            p(style = "margin: 0; font-weight: 600; color: #856404;",
+              paste0("\u26A0 No matching pitch found for ", input$cn_catcher,
+                     " / ", input$cn_batter, " / Inn ", input$cn_inning,
+                     " / ", input$cn_balls, "-", input$cn_strikes)),
+            p(style = "margin: 4px 0 0 0; color: #856404; font-size: 13px;",
+              "Note saved anyway \u2014 it will appear in CatcherNotes column as unmatched.")
+        )
+      }
+    })
+    
+    showNotification(
+      paste0("Added: ", result_text, " (", input$cn_catcher, " / ", input$cn_batter, 
+             " / Inn ", input$cn_inning, " / ", input$cn_balls, "-", input$cn_strikes, ")"),
+      type = "message", duration = 3
+    )
+  })
+  
+  # Render the notes table
+  output$cn_notes_table <- DT::renderDataTable({
+    notes <- catcher_notes_list()
+    if (nrow(notes) == 0) return(NULL)
+    
+    display_notes <- notes %>%
+      mutate(
+        Count = paste0(Balls, "-", Strikes),
+        Match = ifelse(is.na(MatchedRow), "\u2717 No match", paste0("\u2713 Row ", MatchedRow))
+      ) %>%
+      select(NoteID, Catcher, Batter, Inning, Count, Result, Match)
+    
+    DT::datatable(
+      display_notes,
+      options = list(
+        scrollX = TRUE, pageLength = 15, dom = "tip",
+        columnDefs = list(list(className = "dt-center", targets = "_all"))
+      ),
+      rownames = FALSE,
+      selection = "single",
+      callback = DT::JS("
+        table.on('click', 'tr', function() {
+          var data = table.row(this).data();
+          if (data) {
+            Shiny.setInputValue('cn_delete_row', data[0], {priority: 'event'});
+          }
+        });
+      ")
+    ) %>%
+      DT::formatStyle("Match",
+        color = DT::styleEqual(c("\u2717 No match"), c("#dc3545")),
+        fontWeight = "bold"
+      )
+  })
+  
+  # Delete a single note by clicking its row
+  observeEvent(input$cn_delete_row, {
+    notes <- catcher_notes_list()
+    note_id <- as.integer(input$cn_delete_row)
+    
+    if (note_id %in% notes$NoteID) {
+      showModal(modalDialog(
+        title = "Delete Catcher Note?",
+        p(paste("Remove note #", note_id, "?")),
+        footer = tagList(
+          actionButton("cn_confirm_delete", "Delete", class = "btn-danger"),
+          modalButton("Cancel")
+        ),
+        size = "s", easyClose = TRUE
+      ))
+    }
+  })
+  
+  observeEvent(input$cn_confirm_delete, {
+    notes <- catcher_notes_list()
+    note_id <- as.integer(input$cn_delete_row)
+    catcher_notes_list(notes %>% filter(NoteID != note_id))
+    removeModal()
+    showNotification(paste("Deleted note #", note_id), type = "message", duration = 2)
+  })
+  
+  # Clear all notes
+  observeEvent(input$cn_clear_all_btn, {
+    showModal(modalDialog(
+      title = "Clear All Catcher Notes?",
+      p("This will remove all logged catcher notes. This cannot be undone."),
+      footer = tagList(
+        actionButton("cn_confirm_clear_all", "Clear All", class = "btn-danger"),
+        modalButton("Cancel")
+      ),
+      size = "s", easyClose = TRUE
+    ))
+  })
+  
+  observeEvent(input$cn_confirm_clear_all, {
+    catcher_notes_list(data.frame(
+      NoteID = integer(0), Catcher = character(0), Batter = character(0),
+      Inning = integer(0), Balls = integer(0), Strikes = integer(0),
+      Result = character(0), MatchedRow = integer(0), stringsAsFactors = FALSE
+    ))
+    removeModal()
+    output$cn_match_feedback <- renderUI({ NULL })
+    showNotification("All catcher notes cleared.", type = "message", duration = 2)
+  })
+  
+  # Catcher notes summary
+  output$cn_summary <- renderText({
+    notes <- catcher_notes_list()
+    if (nrow(notes) == 0) return("No notes logged yet.")
+    
+    n_matched <- sum(!is.na(notes$MatchedRow))
+    n_unmatched <- sum(is.na(notes$MatchedRow))
+    result_counts <- table(notes$Result)
+    result_str <- paste(names(result_counts), "(", result_counts, ")", collapse = ", ")
+    
+    paste(
+      paste("Total notes:", nrow(notes)),
+      paste("Matched:", n_matched, "| Unmatched:", n_unmatched),
+      paste("Results:", result_str),
+      sep = "\n"
+    )
+  })
+
+  build_download_data <- function() {
+    df <- processed_data()
+    if (is.null(df)) return(NULL)
+    
+    # ── Full processing mode: clean + stuff+ ──
+    if (!is.null(input$download_mode) && input$download_mode == "full") {
+      df <- tryCatch({
+        showNotification("Running clean_college_data()...", type = "message", duration = 2)
+        cleaned <- clean_college_data(df)
+        
+        showNotification("Predicting Stuff+...", type = "message", duration = 2)
+        cleaned <- predict_stuffplus(cleaned)
+        
+        showNotification(
+          paste0("Full processing complete: ", nrow(cleaned), " rows × ", ncol(cleaned), " columns"),
+          type = "message", duration = 4
+        )
+        cleaned
+      }, error = function(e) {
+        showNotification(paste("Processing error:", e$message), type = "error", duration = 8)
+        processed_data()
+      })
+    }
+
+    if (!is.null(input$download_team_filter) && input$download_team_filter != "all") {
+      if (input$download_team_filter == "coastal_pitchers" && "PitcherTeam" %in% names(df)) {
+        df <- df %>% filter(PitcherTeam == "COA_CHA")
+      } else if (input$download_team_filter == "coastal_hitters" && "BatterTeam" %in% names(df)) {
+        df <- df %>% filter(BatterTeam == "COA_CHA")
+      }
+    }
+    
+    # ── Merge catcher notes into existing Notes column ──
+    notes <- catcher_notes_list()
+    
+    if (nrow(notes) == 0) return(df)
+    
+    # Initialize Notes column if not present
+    if (!"Notes" %in% names(df)) {
+      df$Notes <- NA_character_
+    }
+    
+    # For each note, append the result into the matched row's Notes
+    for (i in seq_len(nrow(notes))) {
+      row_idx <- notes$MatchedRow[i]
+      result  <- notes$Result[i]
+      
+      if (!is.na(row_idx) && row_idx >= 1 && row_idx <= nrow(df)) {
+        existing <- df$Notes[row_idx]
+        if (is.na(existing) || existing == "") {
+          df$Notes[row_idx] <- result
+        } else {
+          df$Notes[row_idx] <- paste(existing, result, sep = " | ")
+        }
+      }
+    }
+    
+    # Append unmatched notes to last row
+    unmatched <- notes %>% filter(is.na(MatchedRow))
+    if (nrow(unmatched) > 0) {
+      unmatched_texts <- paste0(
+        unmatched$Result, " (", unmatched$Catcher, "/", unmatched$Batter,
+        " Inn", unmatched$Inning, " ", unmatched$Balls, "-", unmatched$Strikes, ")"
+      )
+      last_row <- nrow(df)
+      existing <- df$Notes[last_row]
+      unmatched_str <- paste0("[UNMATCHED] ", paste(unmatched_texts, collapse = "; "))
+      if (is.na(existing) || existing == "") {
+        df$Notes[last_row] <- unmatched_str
+      } else {
+        df$Notes[last_row] <- paste(existing, unmatched_str, sep = " | ")
+      }
+    }
+    
+    return(df)
+  }
+
+  
+  # ══════════════════════════════════════════════════════════════
+  # End Catcher Notes
+  # ══════════════════════════════════════════════════════════════
+  
+  # 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()
+    result <- merge_result()
+    notes <- catcher_notes_list()
+    
+    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"
+    }
+    
+    notes_summary <- if (nrow(notes) > 0) {
+      n_matched <- sum(!is.na(notes$MatchedRow))
+      paste0("Catcher notes: ", nrow(notes), " total (", n_matched, " matched to rows)")
+    } else {
+      "Catcher notes: None"
+    }
+    
+    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"
+            }),
+      bat_tracking_summary,
+      notes_summary,
+      paste("Source format:", toupper(uploaded_file_type())),
+      paste("Date format:", if (input$date_format == "mdyy") "M/D/YY" else "YYYY-MM-DD"),
+      sep = "\n"
+    )
+    
+    return(summary_text)
+  })
+  
+  # Download handler: CSV or Parquet with custom filename — NOW includes catcher notes
+  output$downloadData <- downloadHandler(
+    filename = function() {
+      base_name <- gsub("[^A-Za-z0-9_\\-]", "_", input$download_filename)
+      if (nchar(trimws(base_name)) == 0) base_name <- paste0("app_ready_COA_", Sys.Date())
+      
+      ext <- input$download_format
+      paste0(base_name, ".", ext)
+    },
+    content = function(file) {
+      download_df <- build_download_data()
+      
+      if (input$download_format == "parquet") {
+        arrow::write_parquet(download_df, file)
+      } else {
+        write.csv(download_df, file, row.names = FALSE)
+      }
+    }
+  )
+
+
+
+  #SCRAPER STUFF
+
+  output$scrape_options <- renderUI({
+    switch(input$scrape_source,
+      "pbp" = tagList(
+        p("Scrapes TrackMan play-by-play data from FTP.")
+      ),
+      "pos" = tagList(
+        p("Scrapes TrackMan player positioning data from FTP.")
+      ),
+      "ncaa" = tagList(
+        selectInput("ncaa_division", "Division:", choices = c("D1", "D2", "D3")),
+        p("Scrapes NCAA scoreboard data via API.")
+      )
+    )
+  })
+  
+  # Scrape button
+observeEvent(input$scrape_btn, {
+  scrape_status_msg("Triggering scrape on GitHub...")
+  
+  gh_token <- Sys.getenv("GITHUB_TOKEN")
+  gh_repo <- Sys.getenv("GITHUB_REPO")
+  
+  result <- tryCatch({
+    httr::POST(
+      paste0("https://api.github.com/repos/", gh_repo, "/actions/workflows/scrape.yml/dispatches"),
+      httr::add_headers(
+        Authorization = paste("Bearer", gh_token),
+        Accept = "application/vnd.github.v3+json"
+      ),
+      body = jsonlite::toJSON(list(
+        ref = "main",
+        inputs = list(
+          start_date = as.character(input$start_date),
+          end_date = as.character(input$end_date),
+          data_type = input$scrape_source
+        )
+      ), auto_unbox = TRUE),
+      encode = "raw"
+    )
+  }, error = function(e) {
+    scrape_status_msg(paste("Failed:", e$message))
+    return(NULL)
+  })
+  
+  if (is.null(result)) return()
+  
+  if (httr::status_code(result) == 204) {
+    scrape_status_msg("Scrape triggered! Waiting for GitHub to finish...")
+    scrape_polling(TRUE)
+  } else {
+    scrape_status_msg(paste("GitHub API error:", httr::status_code(result)))
+  }
+})
+
+# Poll GitHub every 15 seconds to check if done
+observe({
+  req(scrape_polling())
+  
+  invalidateLater(15000, session)
+  
+  gh_token <- Sys.getenv("GITHUB_TOKEN")
+  gh_repo <- Sys.getenv("GITHUB_REPO")
+  
+  resp <- tryCatch({
+    httr::GET(
+      paste0("https://api.github.com/repos/", gh_repo, "/actions/runs?per_page=1"),
+      httr::add_headers(
+        Authorization = paste("Bearer", gh_token),
+        Accept = "application/vnd.github.v3+json"
+      )
+    )
+  }, error = function(e) { NULL })
+  
+  if (is.null(resp)) return()
+  
+  runs <- jsonlite::fromJSON(httr::content(resp, as = "text", encoding = "UTF-8"))
+  
+  if (length(runs$workflow_runs) == 0) return()
+  
+  latest <- runs$workflow_runs[1, ]
+  status <- latest$status
+  conclusion <- latest$conclusion
+  
+  if (status == "completed") {
+    scrape_polling(FALSE)
+    
+    if (conclusion == "success") {
+      scrape_status_msg("GitHub finished! Fetching data...")
+      
+      filename <- paste0(input$scrape_source, "_", input$start_date, "_to_", input$end_date, ".csv.gz")
+      url <- paste0("https://api.github.com/repos/", gh_repo, "/contents/data/", filename)
+      
+      data <- tryCatch({
+        file_resp <- httr::GET(
+          url,
+          httr::add_headers(
+            Authorization = paste("Bearer", gh_token),
+            Accept = "application/vnd.github.v3.raw"
+          )
+        )
+        
+        if (httr::status_code(file_resp) == 200) {
+          tmp <- tempfile(fileext = ".csv.gz")
+          writeBin(httr::content(file_resp, as = "raw"), tmp)
+          read_csv(gzfile(tmp))
+        } else {
+          NULL
+        }
+      }, error = function(e) { NULL })
+      
+      if (!is.null(data) && nrow(data) > 0) {
+        
+        if (input$scrape_source == "pbp") {
+          scrape_status_msg("Processing data...")
+          
+          data <- tryCatch({
+            d <- clean_college_data(data)
+            d <- predict_stuffplus(d)
+            d
+          }, error = function(e) {
+            scrape_status_msg(paste("Processing error:", e$message))
+            data
+          })
+        }
+        
+        scraped_data(data)
+        scrape_status_msg(paste0("Done! ", nrow(data), " rows \u00D7 ", ncol(data), " columns."))
+      } else {
+        scrape_status_msg("Scrape finished but couldn't fetch the file. Try 'Fetch Results' manually.")
+      }
+      
+    } else {
+      scrape_status_msg(paste("GitHub Action failed:", conclusion))
+    }
+    
+  } else {
+    scrape_status_msg(paste0("GitHub is running... (status: ", status, ")"))
+  }
+})
+  
+  # Status text
+  output$scrape_status <- renderText({ scrape_status_msg() })
+  
+  # Preview table
+  output$scrape_preview <- DT::renderDataTable({
+    req(scraped_data())
+    DT::datatable(scraped_data(), options = list(scrollX = TRUE, pageLength = 10))
+  })
+  
+  # Download
+  output$download_scrape <- downloadHandler(
+    filename = function() {
+      label <- switch(input$scrape_source, "pbp" = "pbp", "pos" = "positional", "ncaa" = "ncaa")
+      paste0("trackman_", label, "_",
+             format(input$start_date, "%Y%m%d"), "_to_",
+             format(input$end_date, "%Y%m%d"), ".csv")
+    },
+    content = function(file) {
+      req(scraped_data())
+      write.csv(scraped_data(), file, row.names = FALSE)
+    }
+  )
+
+
+observeEvent(input$upload_hf_btn, {
+  req(scraped_data())
+  
+  hf_token <- Sys.getenv("HF_WRITE_TOKEN")
+  repo_id <- "CoastalBaseball/2026MasterDataset"
+  timestamp <- format(Sys.time(), "%Y%m%d_%H%M%S")
+  
+  upload_to_hf <- function(new_data, folder, index_file, label) {
+    scrape_status_msg(paste0("Checking existing UIDs for ", label, "..."))
+    
+    existing_uids <- tryCatch({
+      tmp_idx <- tempfile(fileext = ".csv.gz")
+      resp <- httr::GET(
+        paste0("https://huggingface.co/datasets/", repo_id, "/resolve/main/", index_file),
+        httr::add_headers(Authorization = paste("Bearer", hf_token)),
+        httr::write_disk(tmp_idx, overwrite = TRUE)
+      )
+      if (httr::status_code(resp) == 200) {
+        d <- read.csv(gzfile(tmp_idx), stringsAsFactors = FALSE)
+        file.remove(tmp_idx)
+        d$PitchUID
+      } else {
+        file.remove(tmp_idx)
+        character(0)
+      }
+    }, error = function(e) { character(0) })
+    
+    scraped_rows <- nrow(new_data)
+    
+    if (length(existing_uids) > 0 && "PitchUID" %in% names(new_data)) {
+      new_only <- new_data %>% filter(!PitchUID %in% existing_uids)
+    } else {
+      new_only <- new_data
+    }
+    
+    new_rows <- nrow(new_only)
+    total_after <- length(existing_uids) + new_rows
+    
+    if (new_rows == 0) {
+      return(paste0(label, ": ", scraped_rows, " rows scraped, 0 new rows added (", length(existing_uids), " total)"))
+    }
+    
+    scrape_status_msg(paste0("Uploading ", new_rows, " new rows for ", label, "..."))
+    
+    hf <- reticulate::import("huggingface_hub")
+    api <- hf$HfApi()
+    
+    tmp_data <- tempfile(fileext = ".parquet")
+    arrow::write_parquet(new_only, tmp_data)
+    
+    api$upload_file(
+      path_or_fileobj = tmp_data,
+      path_in_repo = paste0(folder, "/", timestamp, ".parquet"),
+      repo_id = repo_id,
+      repo_type = "dataset",
+      token = hf_token
+    )
+    file.remove(tmp_data)
+    
+    scrape_status_msg(paste0("Updating ", label, " index..."))
+    
+    all_uids <- data.frame(PitchUID = c(existing_uids, new_only$PitchUID))
+    tmp_idx <- tempfile(fileext = ".csv.gz")
+    gz <- gzfile(tmp_idx, "w")
+    write.csv(all_uids, gz, row.names = FALSE)
+    close(gz)
+    
+    api$upload_file(
+      path_or_fileobj = tmp_idx,
+      path_in_repo = index_file,
+      repo_id = repo_id,
+      repo_type = "dataset",
+      token = hf_token
+    )
+    file.remove(tmp_idx)
+    
+    rm(new_only, all_uids); gc()
+    paste0(label, ": ", scraped_rows, " rows scraped, ", new_rows, " new rows added (", total_after, " total)")
+  }
+  
+  if (input$scrape_source == "pbp") {
+    msg1 <- upload_to_hf(scraped_data(), "pbp", "pbp_uid_index.csv.gz", "Master Dataset")
+    gc()
+    
+    cp <- scraped_data() %>% filter(PitcherTeam == "COA_CHA")
+    msg2 <- if (nrow(cp) > 0) {
+      upload_to_hf(cp, "coastal_pitchers", "coastal_pitchers_uid_index.csv.gz", "Coastal Pitchers")
+    } else { "Coastal Pitchers: No matching rows" }
+    rm(cp); gc()
+    
+    ch <- scraped_data() %>% filter(BatterTeam == "COA_CHA")
+    msg3 <- if (nrow(ch) > 0) {
+      upload_to_hf(ch, "coastal_hitters", "coastal_hitters_uid_index.csv.gz", "Coastal Hitters")
+    } else { "Coastal Hitters: No matching rows" }
+    rm(ch); gc()
+    
+    scrape_status_msg(paste(msg1, msg2, msg3, sep = "\n"))
+    
+  } else if (input$scrape_source == "pos") {
+    msg1 <- upload_to_hf(scraped_data(), "pos", "pos_uid_index.csv.gz", "Positional Dataset")
+    scrape_status_msg(msg1)
+    
+  } else if (input$scrape_source == "ncaa") {
+    msg1 <- upload_to_hf(scraped_data(), "ncaa_pbp", "ncaa_pbp_uid_index.csv.gz", "NCAA PBP Dataset")
+    scrape_status_msg(msg1)
+  }
+})
+    
 }
 
 shinyApp(ui = ui, server = server)