Calendar/src/managers/HeaderManager.ts

import { eventBus } from '../core/EventBus';
import { calendarConfig } from '../core/CalendarConfig';
import { CalendarTypeFactory } from '../factories/CalendarTypeFactory';
import { CoreEvents } from '../constants/CoreEvents';
import { HeaderRenderContext } from '../renderers/HeaderRenderer';
import { ResourceCalendarData } from '../types/CalendarTypes';
import { DragMouseEnterHeaderEventPayload, DragMouseLeaveHeaderEventPayload } from '../types/EventTypes';

/**
 * HeaderManager - Handles all header-related event logic
 * Separates event handling from rendering concerns
 */
export class HeaderManager {
  private cachedCalendarHeader: HTMLElement | null = null;
  
  // Event listeners for drag events
  private dragMouseEnterHeaderListener: ((event: Event) => void) | null = null;
  private dragMouseLeaveHeaderListener: ((event: Event) => void) | null = null;

  constructor() {
    // Bind methods for event listeners
    this.setupHeaderDragListeners = this.setupHeaderDragListeners.bind(this);
    this.destroy = this.destroy.bind(this);
    
    // Listen for navigation events to update header
    this.setupNavigationListener();
  }

  /**
   * Initialize header with initial date
   */
  public initializeHeader(currentDate: Date, resourceData: ResourceCalendarData | null = null): void {
    this.updateHeader(currentDate, resourceData);
  }

  /**
   * Get cached calendar header element
   */
  private getCalendarHeader(): HTMLElement | null {
    if (!this.cachedCalendarHeader) {
      this.cachedCalendarHeader = document.querySelector('swp-calendar-header');
    }
    return this.cachedCalendarHeader;
  }

  /**
   * Setup header drag event listeners - REFACTORED to listen to DragDropManager events
   */
  public setupHeaderDragListeners(): void {
    console.log('🎯 HeaderManager: Setting up drag event listeners');

    // Create and store event listeners
    this.dragMouseEnterHeaderListener = (event: Event) => {
      const { targetDate, mousePosition, originalElement, cloneElement } = (event as CustomEvent<DragMouseEnterHeaderEventPayload>).detail;
      
      console.log('🎯 HeaderManager: Received drag:mouseenter-header', {
        targetDate,
        originalElement: !!originalElement,
        cloneElement: !!cloneElement
      });
      
      if (targetDate) {
        // Ensure all-day container exists
        this.ensureAllDayContainer();
        
        const calendarType = calendarConfig.getCalendarMode();
        const headerRenderer = CalendarTypeFactory.getHeaderRenderer(calendarType);
        
       
      }
    };

    this.dragMouseLeaveHeaderListener = (event: Event) => {
      const { targetDate, mousePosition, originalElement, cloneElement } = (event as CustomEvent<DragMouseLeaveHeaderEventPayload>).detail;
      
      console.log('🚪 HeaderManager: Received drag:mouseleave-header', {
        targetDate,
        originalElement: !!originalElement,
        cloneElement: !!cloneElement
      });
      
      eventBus.emit('header:mouseleave', {
        element: this.getCalendarHeader(),
        targetDate,
        originalElement,
        cloneElement
      });
    };

    // Listen for drag events from DragDropManager
    eventBus.on('drag:mouseenter-header', this.dragMouseEnterHeaderListener);
    eventBus.on('drag:mouseleave-header', this.dragMouseLeaveHeaderListener);
    
    console.log('✅ HeaderManager: Drag event listeners attached');
  }

  /**
   * Ensure all-day container exists in header
   */
  private ensureAllDayContainer(): void {
    const calendarHeader = this.getCalendarHeader();
    if (!calendarHeader) return;
    
    let allDayContainer = calendarHeader.querySelector('swp-allday-container');
    
    if (!allDayContainer) {
      console.log('📍 HeaderManager: All-day container missing, requesting creation...');
      eventBus.emit('allday:ensure-container');
    }
  }


  /**
   * Setup navigation event listener
   */
  private setupNavigationListener(): void {
    eventBus.on(CoreEvents.NAVIGATION_COMPLETED, (event) => {
      const { currentDate, resourceData } = (event as CustomEvent).detail;
      this.updateHeader(currentDate, resourceData);
    });

    // Also listen for date changes (including initial setup)
    eventBus.on(CoreEvents.DATE_CHANGED, (event) => {
      const { currentDate } = (event as CustomEvent).detail;
      this.updateHeader(currentDate, null);
    });

    // Listen for workweek header updates after grid rebuild
    eventBus.on('workweek:header-update', (event) => {
      const { currentDate } = (event as CustomEvent).detail;
      this.clearCache(); // Clear cache since DOM was cleared
      this.updateHeader(currentDate, null);
    });

  }

  /**
   * Update header content for navigation
   */
  private updateHeader(currentDate: Date, resourceData: ResourceCalendarData | null = null): void {
    const calendarHeader = this.getOrCreateCalendarHeader();
    if (!calendarHeader) return;

       // Clear existing content
    calendarHeader.innerHTML = '';

    // Render new header content
    const calendarType = calendarConfig.getCalendarMode();
    const headerRenderer = CalendarTypeFactory.getHeaderRenderer(calendarType);
    
    const context: HeaderRenderContext = {
      currentWeek: currentDate,
      config: calendarConfig,
      resourceData: resourceData
    };

    headerRenderer.render(calendarHeader, context);

    // Setup event listeners on the new content
    this.setupHeaderDragListeners();

    // Notify other managers that header was rebuilt
    eventBus.emit('header:rebuilt', {
      headerElement: calendarHeader
    });
  }

  /**
   * Get or create calendar header element
   */
  private getOrCreateCalendarHeader(): HTMLElement | null {
    let calendarHeader = this.getCalendarHeader();
    
    if (!calendarHeader) {
      // Find grid container and create header
      const gridContainer = document.querySelector('swp-grid-container');
      if (gridContainer) {
        calendarHeader = document.createElement('swp-calendar-header');
        // Insert header as first child
        gridContainer.insertBefore(calendarHeader, gridContainer.firstChild);
        this.cachedCalendarHeader = calendarHeader;
      }
    }
    
    return calendarHeader;
  }


  /**
   * Clear cached header reference
   */
  public clearCache(): void {
    this.cachedCalendarHeader = null;
  }

  /**
   * Clean up resources and event listeners
   */
  public destroy(): void {
     
    // Remove eventBus listeners
    if (this.dragMouseEnterHeaderListener) {
      eventBus.off('drag:mouseenter-header', this.dragMouseEnterHeaderListener);
    }
    if (this.dragMouseLeaveHeaderListener) {
      eventBus.off('drag:mouseleave-header', this.dragMouseLeaveHeaderListener);
    }
    
    // Clear references
    this.dragMouseEnterHeaderListener = null;
    this.dragMouseLeaveHeaderListener = null;
    
    this.clearCache();
  }
}