Calendar/src/managers/DragDropManager.ts

/**
 * DragDropManager - Optimized drag and drop with consolidated position calculations
 * Reduces redundant DOM queries and improves performance through caching
 */

import { IEventBus } from '../types/CalendarTypes';
import { calendarConfig } from '../core/CalendarConfig';
import { DateCalculator } from '../utils/DateCalculator';

interface CachedElements {
  scrollContainer: HTMLElement | null;
  currentColumn: HTMLElement | null;
  lastColumnDate: string | null;
}

interface Position {
  x: number;
  y: number;
}

export class DragDropManager {
  private eventBus: IEventBus;
  
  // Mouse tracking with optimized state
  private isMouseDown = false;
  private lastMousePosition: Position = { x: 0, y: 0 };
  private lastLoggedPosition: Position = { x: 0, y: 0 };
  private currentMouseY = 0;
  private mouseOffset: Position = { x: 0, y: 0 };
  
  // Drag state
  private draggedEventId: string | null = null;
  private originalElement: HTMLElement | null = null;
  private currentColumn: string | null = null;
  
  // Cached DOM elements for performance
  private cachedElements: CachedElements = {
    scrollContainer: null,
    currentColumn: null,
    lastColumnDate: null
  };
  
  // Auto-scroll properties
  private autoScrollAnimationId: number | null = null;
  private readonly scrollSpeed = 10; // pixels per frame
  private readonly scrollThreshold = 30; // pixels from edge
  
  // Snap configuration
  private snapIntervalMinutes = 15; // Default 15 minutes
  private hourHeightPx = 60; // From CSS --hour-height
  
  // Event listener references for proper cleanup
  private boundHandlers = {
    mouseMove: this.handleMouseMove.bind(this),
    mouseDown: this.handleMouseDown.bind(this),
    mouseUp: this.handleMouseUp.bind(this)
  };
  
  private get snapDistancePx(): number {
    return (this.snapIntervalMinutes / 60) * this.hourHeightPx;
  }
  
  constructor(eventBus: IEventBus) {
    this.eventBus = eventBus;

    // Get config values
    const gridSettings = calendarConfig.getGridSettings();
    this.hourHeightPx = gridSettings.hourHeight;
    
    this.init();
  }
  
  /**
   * Configure snap interval
   */
  public setSnapInterval(minutes: number): void {
    this.snapIntervalMinutes = minutes;
  }
  
  /**
   * Initialize with optimized event listener setup
   */
  private init(): void {
    // Use bound handlers for proper cleanup
    document.body.addEventListener('mousemove', this.boundHandlers.mouseMove);
    document.body.addEventListener('mousedown', this.boundHandlers.mouseDown);
    document.body.addEventListener('mouseup', this.boundHandlers.mouseUp);
    
    // Listen for header mouseover events
    this.eventBus.on('header:mouseover', (event) => {
      const { element, targetDate, headerRenderer } = (event as CustomEvent).detail;
      
      if (this.isMouseDown && this.draggedEventId && targetDate) {
        // Emit event to convert to all-day
        this.eventBus.emit('drag:convert-to-allday', {
          eventId: this.draggedEventId,
          targetDate,
          element,
          headerRenderer
        });
      }
    });
  }
  
  private handleMouseDown(event: MouseEvent): void {
    this.isMouseDown = true;
    this.lastMousePosition = { x: event.clientX, y: event.clientY };
    this.lastLoggedPosition = { x: event.clientX, y: event.clientY };
    
    // Check if mousedown is on an event
    const target = event.target as HTMLElement;
    let eventElement = target;
    
    while (eventElement && eventElement.tagName !== 'SWP-EVENTS-LAYER') {
      if (eventElement.tagName === 'SWP-EVENT' || eventElement.tagName === 'SWP-ALLDAY-EVENT') {
        break;
      }
      eventElement = eventElement.parentElement as HTMLElement;
      if (!eventElement) return;
    }
    
    // If we reached SWP-EVENTS-LAYER without finding an event, return
    if (!eventElement || eventElement.tagName === 'SWP-EVENTS-LAYER') {
      return;
    }
    
    // Found an event - start dragging
    if (eventElement) {
      this.originalElement = eventElement;
      this.draggedEventId = eventElement.dataset.eventId || null;
      
      // Calculate mouse offset within event
      const eventRect = eventElement.getBoundingClientRect();
      this.mouseOffset = {
        x: event.clientX - eventRect.left,
        y: event.clientY - eventRect.top
      };
      
      // Detect current column
      const column = this.detectColumn(event.clientX, event.clientY);
      if (column) {
        this.currentColumn = column;
      }
      
      // Emit drag start event
      this.eventBus.emit('drag:start', {
        originalElement: eventElement,
        eventId: this.draggedEventId,
        mousePosition: { x: event.clientX, y: event.clientY },
        mouseOffset: this.mouseOffset,
        column: this.currentColumn
      });
      
    }
  }
  
  /**
   * Optimized mouse move handler with consolidated position calculations
   */
  private handleMouseMove(event: MouseEvent): void {
    this.currentMouseY = event.clientY;
    
    if (this.isMouseDown && this.draggedEventId) {
      const currentPosition: Position = { x: event.clientX, y: event.clientY };
      const deltaY = Math.abs(currentPosition.y - this.lastLoggedPosition.y);
      
      // Check for snap interval vertical movement
      if (deltaY >= this.snapDistancePx) {
        this.lastLoggedPosition = currentPosition;
        
        // Consolidated position calculations
        const positionData = this.calculateDragPosition(currentPosition);
        
        // Emit drag move event with consolidated data
        this.eventBus.emit('drag:move', {
          eventId: this.draggedEventId,
          mousePosition: currentPosition,
          snappedY: positionData.snappedY,
          column: positionData.column,
          mouseOffset: this.mouseOffset
        });
      }
      
      // Check for auto-scroll
      this.checkAutoScroll(event);
      
      // Check for column change using cached data
      const newColumn = this.getColumnFromCache(currentPosition);
      if (newColumn && newColumn !== this.currentColumn) {
        const previousColumn = this.currentColumn;
        this.currentColumn = newColumn;
        
        this.eventBus.emit('drag:column-change', {
          eventId: this.draggedEventId,
          previousColumn,
          newColumn,
          mousePosition: currentPosition
        });
      }
    }
  }
  
  /**
   * Optimized mouse up handler with consolidated cleanup
   */
  private handleMouseUp(event: MouseEvent): void {
    if (!this.isMouseDown) return;
    
    this.isMouseDown = false;
    this.stopAutoScroll();
    
    if (this.draggedEventId && this.originalElement) {
      const finalPosition: Position = { x: event.clientX, y: event.clientY };
      
      // Use consolidated position calculation
      const positionData = this.calculateDragPosition(finalPosition);
      
      // Emit drag end event
      this.eventBus.emit('drag:end', {
        eventId: this.draggedEventId,
        originalElement: this.originalElement,
        finalPosition,
        finalColumn: positionData.column,
        finalY: positionData.snappedY
      });
      
      // Clean up drag state
      this.cleanupDragState();
    }
  }
  
  /**
   * Consolidated position calculation method
   */
  private calculateDragPosition(mousePosition: Position): { column: string | null; snappedY: number } {
    const column = this.detectColumn(mousePosition.x, mousePosition.y);
    const snappedY = this.calculateSnapPosition(mousePosition.y, column);
    
    return { column, snappedY };
  }

  /**
   * Optimized snap position calculation with caching
   */
  private calculateSnapPosition(mouseY: number, column: string | null = null): number {
    const targetColumn = column || this.currentColumn;
    
    // Use cached column element if available
    const columnElement = this.getCachedColumnElement(targetColumn);
    if (!columnElement) return mouseY;
    
    const columnRect = columnElement.getBoundingClientRect();
    const relativeY = mouseY - columnRect.top - this.mouseOffset.y;
    
    // Snap to nearest interval using DateCalculator precision
    const snappedY = Math.round(relativeY / this.snapDistancePx) * this.snapDistancePx;
    
    return Math.max(0, snappedY);
  }
  
  /**
   * Optimized column detection with caching
   */
  private detectColumn(mouseX: number, mouseY: number): string | null {
    const element = document.elementFromPoint(mouseX, mouseY);
    if (!element) return null;
    
    // Walk up DOM tree to find swp-day-column
    let current = element as HTMLElement;
    while (current && current.tagName !== 'SWP-DAY-COLUMN') {
      current = current.parentElement as HTMLElement;
      if (!current) return null;
    }
    
    const columnDate = current.dataset.date || null;
    
    // Update cache if we found a new column
    if (columnDate && columnDate !== this.cachedElements.lastColumnDate) {
      this.cachedElements.currentColumn = current;
      this.cachedElements.lastColumnDate = columnDate;
    }
    
    return columnDate;
  }

  /**
   * Get column from cache or detect new one
   */
  private getColumnFromCache(mousePosition: Position): string | null {
    // Try to use cached column first
    if (this.cachedElements.currentColumn && this.cachedElements.lastColumnDate) {
      const rect = this.cachedElements.currentColumn.getBoundingClientRect();
      if (mousePosition.x >= rect.left && mousePosition.x <= rect.right) {
        return this.cachedElements.lastColumnDate;
      }
    }
    
    // Cache miss - detect new column
    return this.detectColumn(mousePosition.x, mousePosition.y);
  }

  /**
   * Get cached column element or query for new one
   */
  private getCachedColumnElement(columnDate: string | null): HTMLElement | null {
    if (!columnDate) return null;
    
    // Return cached element if it matches
    if (this.cachedElements.lastColumnDate === columnDate && this.cachedElements.currentColumn) {
      return this.cachedElements.currentColumn;
    }
    
    // Query for new element and cache it
    const element = document.querySelector(`swp-day-column[data-date="${columnDate}"]`) as HTMLElement;
    if (element) {
      this.cachedElements.currentColumn = element;
      this.cachedElements.lastColumnDate = columnDate;
    }
    
    return element;
  }
  
  /**
   * Optimized auto-scroll check with cached container
   */
  private checkAutoScroll(event: MouseEvent): void {
    // Use cached scroll container
    if (!this.cachedElements.scrollContainer) {
      this.cachedElements.scrollContainer = document.querySelector('swp-scrollable-content') as HTMLElement;
      if (!this.cachedElements.scrollContainer) {
        return;
      }
    }
    
    const containerRect = this.cachedElements.scrollContainer.getBoundingClientRect();
    const mouseY = event.clientY;
    
    // Calculate distances from edges
    const distanceFromTop = mouseY - containerRect.top;
    const distanceFromBottom = containerRect.bottom - mouseY;
    
    // Check if we need to scroll
    if (distanceFromTop <= this.scrollThreshold && distanceFromTop > 0) {
      this.startAutoScroll('up');
    } else if (distanceFromBottom <= this.scrollThreshold && distanceFromBottom > 0) {
      this.startAutoScroll('down');
    } else {
      this.stopAutoScroll();
    }
  }
  
  /**
   * Optimized auto-scroll with cached container reference
   */
  private startAutoScroll(direction: 'up' | 'down'): void {
    if (this.autoScrollAnimationId !== null) return;
    
    const scroll = () => {
      if (!this.cachedElements.scrollContainer || !this.isMouseDown) {
        this.stopAutoScroll();
        return;
      }
      
      const scrollAmount = direction === 'up' ? -this.scrollSpeed : this.scrollSpeed;
      this.cachedElements.scrollContainer.scrollTop += scrollAmount;
      
      // Emit updated position during scroll - adjust for scroll movement
      if (this.draggedEventId) {
        // During autoscroll, we need to calculate position relative to the scrolled content
        // The mouse hasn't moved, but the content has scrolled
        const columnElement = this.getCachedColumnElement(this.currentColumn);
        if (columnElement) {
          const columnRect = columnElement.getBoundingClientRect();
          // Calculate position relative to column, accounting for scroll movement
          const relativeY = this.currentMouseY - columnRect.top - this.mouseOffset.y;
          const snappedY = Math.round(relativeY / this.snapDistancePx) * this.snapDistancePx;
          const finalSnappedY = Math.max(0, snappedY);
          
          this.eventBus.emit('drag:auto-scroll', {
            eventId: this.draggedEventId,
            snappedY: finalSnappedY,
            scrollTop: this.cachedElements.scrollContainer.scrollTop
          });
        }
      }
      
      this.autoScrollAnimationId = requestAnimationFrame(scroll);
    };
    
    this.autoScrollAnimationId = requestAnimationFrame(scroll);
  }
  
  /**
   * Stop auto-scroll animation
   */
  private stopAutoScroll(): void {
    if (this.autoScrollAnimationId !== null) {
      cancelAnimationFrame(this.autoScrollAnimationId);
      this.autoScrollAnimationId = null;
    }
  }
  
  /**
   * Clean up drag state
   */
  private cleanupDragState(): void {
    this.draggedEventId = null;
    this.originalElement = null;
    this.currentColumn = null;
    
    // Clear cached elements
    this.cachedElements.currentColumn = null;
    this.cachedElements.lastColumnDate = null;
  }

  /**
   * Clean up all resources and event listeners
   */
  public destroy(): void {
    this.stopAutoScroll();
    
    // Remove event listeners using bound references
    document.body.removeEventListener('mousemove', this.boundHandlers.mouseMove);
    document.body.removeEventListener('mousedown', this.boundHandlers.mouseDown);
    document.body.removeEventListener('mouseup', this.boundHandlers.mouseUp);
    
    // Clear all cached elements
    this.cachedElements.scrollContainer = null;
    this.cachedElements.currentColumn = null;
    this.cachedElements.lastColumnDate = null;
    
    // Clean up drag state
    this.cleanupDragState();
  }
}