// Grid structure management - Simple CSS Grid Implementation with Strategy Pattern

import { eventBus } from '../core/EventBus';
import { calendarConfig } from '../core/CalendarConfig';
import { EventTypes } from '../constants/EventTypes';
import { StateEvents } from '../types/CalendarState';
import { DateUtils } from '../utils/DateUtils';
import { ResourceCalendarData } from '../types/CalendarTypes';
import { CalendarTypeFactory } from '../factories/CalendarTypeFactory';
import { HeaderRenderContext } from '../renderers/HeaderRenderer';
import { ColumnRenderContext } from '../renderers/ColumnRenderer';

/**
 * Grid position interface
 */
interface GridPosition {
  minutes: number;
  time: string;
  y: number;
}

/**
 * Manages the calendar grid structure using simple CSS Grid with Strategy Pattern
 */
export class GridManager {
  private container: HTMLElement | null = null;
  private grid: HTMLElement | null = null;
  private currentWeek: Date | null = null;
  private allDayEvents: any[] = []; // Store all-day events for current week
  private resourceData: ResourceCalendarData | null = null; // Store resource data for resource calendar
  
  constructor() {
    console.log('🏗️ GridManager: Constructor called');
    this.init();
  }

  private init(): void {
    this.findElements();
    this.subscribeToEvents();
    
    // Set initial current week to today if not set
    if (!this.currentWeek) {
      this.currentWeek = this.getWeekStart(new Date());
      console.log('GridManager: Set initial currentWeek to', this.currentWeek);
      // Don't render immediately - wait for proper initialization event
      console.log('GridManager: Waiting for initialization complete before rendering');
    }
  }

  private getWeekStart(date: Date): Date {
    // Use DateUtils for consistent week calculation (Sunday = 0)
    return DateUtils.getWeekStart(date, 0);
  }

  private findElements(): void {
    this.grid = document.querySelector('swp-calendar-container');
    console.log('GridManager: findElements called, found swp-calendar-container:', !!this.grid);
  }

  private subscribeToEvents(): void {
    // State-driven events removed - render() is now called directly by CalendarManager

    // Re-render grid on config changes
    eventBus.on(EventTypes.CONFIG_UPDATE, (e: Event) => {
      const detail = (e as CustomEvent).detail;
      if (['dayStartHour', 'dayEndHour', 'hourHeight', 'view', 'weekDays', 'fitToWidth'].includes(detail.key)) {
        this.render();
      }
    });

    // Re-render on calendar type change
    eventBus.on(EventTypes.CALENDAR_TYPE_CHANGED, () => {
      this.render();
    });

    // Re-render on view change
    eventBus.on(EventTypes.VIEW_CHANGE, () => {
      this.render();
    });

    // Re-render on period change
    eventBus.on(EventTypes.PERIOD_CHANGE, (e: Event) => {
      const detail = (e as CustomEvent).detail;
      this.currentWeek = detail.week;
      this.render();
    });

    // Handle week changes from NavigationManager
    eventBus.on(EventTypes.WEEK_CHANGED, (e: Event) => {
      const detail = (e as CustomEvent).detail;
      this.currentWeek = detail.weekStart;
      this.render();
    });

    // Handle events loaded
    eventBus.on(EventTypes.EVENTS_LOADED, (e: Event) => {
      const detail = (e as CustomEvent).detail;
      this.updateAllDayEvents(detail.events);
    });

    // Handle data loaded for resource mode
    eventBus.on(StateEvents.DATA_LOADED, (e: Event) => {
      const detail = (e as CustomEvent).detail;
      console.log(`GridManager: Received DATA_LOADED`);
      
      if (detail.data && detail.data.calendarMode === 'resource') {
        // Resource data will be passed in the state event
        // For now just update grid styles
        this.updateGridStyles();
      }
    });

    // Handle grid clicks
    this.setupGridInteractions();
  }

  /**
   * Set resource data for resource calendar mode
   */
  public setResourceData(resourceData: ResourceCalendarData | null): void {
    this.resourceData = resourceData;
    console.log('GridManager: Set resource data:', resourceData ? `${resourceData.resources.length} resources` : 'null');
  }

  /**
   * Render the complete grid structure - now returns Promise for direct calls
   */
  async render(): Promise<void> {
    if (!this.grid) {
      console.warn('GridManager: render() called but this.grid is null, re-finding elements');
      this.findElements();
      if (!this.grid) {
        throw new Error('GridManager: swp-calendar-container not found, cannot render');
      }
    }

    console.log('GridManager: Starting render with grid element:', this.grid);
    this.updateGridStyles();
    this.renderGrid();
    
    const columnCount = this.getColumnCount();
    console.log(`GridManager: Render complete - created ${columnCount} columns`);
    
    // Emit GRID_RENDERED event to trigger event rendering
    const weekEnd = this.currentWeek ? new Date(this.currentWeek.getTime() + 6 * 24 * 60 * 60 * 1000) : null;
    eventBus.emit(EventTypes.GRID_RENDERED, {
      container: this.grid,
      currentWeek: this.currentWeek,
      startDate: this.currentWeek,
      endDate: weekEnd,
      columnCount: columnCount
    });
  }

  /**
   * Get current column count based on calendar mode
   */
  private getColumnCount(): number {
    const calendarType = calendarConfig.getCalendarMode();
    
    if (calendarType === 'resource' && this.resourceData) {
      return this.resourceData.resources.length;
    } else if (calendarType === 'date') {
      const dateSettings = calendarConfig.getDateViewSettings();
      switch (dateSettings.period) {
        case 'day': return 1;
        case 'week': return dateSettings.weekDays;
        case 'month': return 7;
        default: return dateSettings.weekDays;
      }
    }
    
    return 7; // Default
  }

  /**
   * Render the complete grid using POC structure
   */
  private renderGrid(): void {
    console.log('GridManager: renderGrid called', {
      hasGrid: !!this.grid,
      hasCurrentWeek: !!this.currentWeek,
      currentWeek: this.currentWeek
    });
    
    if (!this.grid || !this.currentWeek) {
      console.warn('GridManager: Cannot render - missing grid or currentWeek');
      return;
    }

    // Only clear and rebuild if grid is empty (first render)
    if (this.grid.children.length === 0) {
      console.log('GridManager: First render - creating grid structure');
      // Create POC structure: header-spacer + time-axis + grid-container
      this.createHeaderSpacer();
      this.createTimeAxis();
      this.createGridContainer();
    } else {
      console.log('GridManager: Re-render - updating existing structure');
      // Just update the calendar header for all-day events
      this.updateCalendarHeader();
    }
    
    console.log('GridManager: Grid rendered successfully with POC structure');
  }

  /**
   * Create header spacer to align time axis with week content
   */
  private createHeaderSpacer(): void {
    if (!this.grid) return;

    const headerSpacer = document.createElement('swp-header-spacer');
    this.grid.appendChild(headerSpacer);
  }

  /**
   * Create time axis (positioned beside grid container) like in POC
   */
  private createTimeAxis(): void {
    if (!this.grid) return;

    const timeAxis = document.createElement('swp-time-axis');
    const timeAxisContent = document.createElement('swp-time-axis-content');
    const gridSettings = calendarConfig.getGridSettings();
    const startHour = gridSettings.dayStartHour;
    const endHour = gridSettings.dayEndHour;
    console.log('GridManager: Creating time axis - startHour:', startHour, 'endHour:', endHour);

    for (let hour = startHour; hour < endHour; hour++) {
      const marker = document.createElement('swp-hour-marker');
      const period = hour >= 12 ? 'PM' : 'AM';
      const displayHour = hour > 12 ? hour - 12 : (hour === 0 ? 12 : hour);
      marker.textContent = `${displayHour} ${period}`;
      timeAxisContent.appendChild(marker);
    }

    timeAxis.appendChild(timeAxisContent);
    this.grid.appendChild(timeAxis);
  }

  /**
   * Create grid container with header and scrollable content using Strategy Pattern
   */
  private createGridContainer(): void {
    if (!this.grid || !this.currentWeek) return;

    const gridContainer = document.createElement('swp-grid-container');
    
    // Create calendar header using Strategy Pattern
    const calendarHeader = document.createElement('swp-calendar-header');
    this.renderCalendarHeader(calendarHeader);
    gridContainer.appendChild(calendarHeader);
    
    // Create scrollable content
    const scrollableContent = document.createElement('swp-scrollable-content');
    const timeGrid = document.createElement('swp-time-grid');
    
    // Add grid lines
    const gridLines = document.createElement('swp-grid-lines');
    timeGrid.appendChild(gridLines);
    
    // Create column container using Strategy Pattern
    const columnContainer = document.createElement('swp-day-columns');
    this.renderColumnContainer(columnContainer);
    timeGrid.appendChild(columnContainer);
    
    scrollableContent.appendChild(timeGrid);
    gridContainer.appendChild(scrollableContent);
    
    this.grid.appendChild(gridContainer);
  }

  /**
   * Render calendar header using Strategy Pattern
   */
  private renderCalendarHeader(calendarHeader: HTMLElement): void {
    if (!this.currentWeek) return;

    const calendarType = calendarConfig.getCalendarMode();
    const headerRenderer = CalendarTypeFactory.getHeaderRenderer(calendarType);
    
    const context: HeaderRenderContext = {
      currentWeek: this.currentWeek,
      config: calendarConfig,
      allDayEvents: this.allDayEvents,
      resourceData: this.resourceData
    };

    headerRenderer.render(calendarHeader, context);

    // Update spacer heights based on all-day events
    this.updateSpacerHeights();
  }

  /**
   * Render column container using Strategy Pattern
   */
  private renderColumnContainer(columnContainer: HTMLElement): void {
    if (!this.currentWeek) return;

    console.log('GridManager: renderColumnContainer called');
    const calendarType = calendarConfig.getCalendarMode();
    const columnRenderer = CalendarTypeFactory.getColumnRenderer(calendarType);
    
    const context: ColumnRenderContext = {
      currentWeek: this.currentWeek,
      config: calendarConfig,
      resourceData: this.resourceData
    };

    columnRenderer.render(columnContainer, context);
  }

  /**
   * Update only the calendar header (for all-day events) without rebuilding entire grid
   */
  private updateCalendarHeader(): void {
    if (!this.grid || !this.currentWeek) return;

    const calendarHeader = this.grid.querySelector('swp-calendar-header');
    if (!calendarHeader) return;

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

    // Re-render headers using Strategy Pattern
    this.renderCalendarHeader(calendarHeader as HTMLElement);
  }

  /**
   * Update all-day events data and re-render if needed
   */
  private updateAllDayEvents(events: any[]): void {
    if (!this.currentWeek) return;

    // Filter all-day events for current week
    const weekStart = this.currentWeek;
    const weekEnd = new Date(weekStart);
    weekEnd.setDate(weekStart.getDate() + 6);

    this.allDayEvents = events.filter(event => {
      if (!event.allDay) return false;
      
      const eventDate = new Date(event.start);
      return eventDate >= weekStart && eventDate <= weekEnd;
    });

    console.log('GridManager: Updated all-day events:', this.allDayEvents.length);
    
    // Update only the calendar header if grid is already rendered
    if (this.grid && this.grid.children.length > 0) {
      this.updateCalendarHeader();
    }
  }

  /**
   * Update spacer heights based on all-day events presence
   */
  private updateSpacerHeights(): void {
    const allDayEventCount = 1;
    const eventHeight = 26; // Height per all-day event in pixels
    const padding = 0; // Top/bottom padding
    const allDayHeight = allDayEventCount > 0 ? (allDayEventCount * eventHeight) + padding : 0;
    
    // Set CSS variable for dynamic spacer height
    document.documentElement.style.setProperty('--all-day-row-height', `${allDayHeight}px`);
    
    console.log('GridManager: Updated --all-day-row-height to', `${allDayHeight}px`, 'for', allDayEventCount, 'events');
  }

  /**
   * Update grid CSS variables
   */
  private updateGridStyles(): void {
    const root = document.documentElement;
    const gridSettings = calendarConfig.getGridSettings();
    const calendar = document.querySelector('swp-calendar') as HTMLElement;
    const calendarType = calendarConfig.getCalendarMode();
    
    // Set CSS variables
    root.style.setProperty('--hour-height', `${gridSettings.hourHeight}px`);
    root.style.setProperty('--minute-height', `${gridSettings.hourHeight / 60}px`);
    root.style.setProperty('--snap-interval', gridSettings.snapInterval.toString());
    root.style.setProperty('--day-start-hour', gridSettings.dayStartHour.toString());
    root.style.setProperty('--day-end-hour', gridSettings.dayEndHour.toString());
    root.style.setProperty('--work-start-hour', gridSettings.workStartHour.toString());
    root.style.setProperty('--work-end-hour', gridSettings.workEndHour.toString());
    
    // Set number of columns based on calendar type
    let columnCount = 7; // Default for date mode
    if (calendarType === 'resource' && this.resourceData) {
      columnCount = this.resourceData.resources.length;
    } else if (calendarType === 'date') {
      const dateSettings = calendarConfig.getDateViewSettings();
      // Calculate columns based on view type - business logic moved from config
      switch (dateSettings.period) {
        case 'day':
          columnCount = 1;
          break;
        case 'week':
          columnCount = dateSettings.weekDays;
          break;
        case 'month':
          columnCount = 7;
          break;
        default:
          columnCount = dateSettings.weekDays;
      }
    }
    root.style.setProperty('--grid-columns', columnCount.toString());
    
    // Set day column min width based on fitToWidth setting
    if (gridSettings.fitToWidth) {
      root.style.setProperty('--day-column-min-width', '50px'); // Small min-width allows columns to fit available space
    } else {
      root.style.setProperty('--day-column-min-width', '250px'); // Default min-width for horizontal scroll mode
    }
    
    // Set fitToWidth data attribute for CSS targeting
    if (calendar) {
      calendar.setAttribute('data-fit-to-width', gridSettings.fitToWidth.toString());
    }
    
    console.log('GridManager: Updated grid styles with', columnCount, 'columns for', calendarType, 'calendar');
  }

  /**
   * Setup grid interaction handlers for POC structure
   */
  private setupGridInteractions(): void {
    if (!this.grid) return;

    // Click handler for day columns (works for both date and resource columns)
    this.grid.addEventListener('click', (e: MouseEvent) => {
      // Ignore if clicking on an event
      if ((e.target as Element).closest('swp-event')) return;
      
      const dayColumn = (e.target as Element).closest('swp-day-column, swp-resource-column') as HTMLElement;
      if (!dayColumn) return;

      const position = this.getClickPosition(e, dayColumn);
      
      eventBus.emit(EventTypes.GRID_CLICK, {
        date: (dayColumn as any).dataset.date,
        resource: (dayColumn as any).dataset.resource,
        employeeId: (dayColumn as any).dataset.employeeId,
        time: position.time,
        minutes: position.minutes
      });
    });

    // Double click handler for day columns
    this.grid.addEventListener('dblclick', (e: MouseEvent) => {
      // Ignore if clicking on an event
      if ((e.target as Element).closest('swp-event')) return;
      
      const dayColumn = (e.target as Element).closest('swp-day-column, swp-resource-column') as HTMLElement;
      if (!dayColumn) return;

      const position = this.getClickPosition(e, dayColumn);
      
      eventBus.emit(EventTypes.GRID_DBLCLICK, {
        date: (dayColumn as any).dataset.date,
        resource: (dayColumn as any).dataset.resource,
        employeeId: (dayColumn as any).dataset.employeeId,
        time: position.time,
        minutes: position.minutes
      });
    });
  }

  /**
   * Get click position in day column (POC structure)
   */
  private getClickPosition(event: MouseEvent, dayColumn: HTMLElement): GridPosition {
    const rect = dayColumn.getBoundingClientRect();
    const y = event.clientY - rect.top;
    
    const gridSettings = calendarConfig.getGridSettings();
    const hourHeight = gridSettings.hourHeight;
    const minuteHeight = hourHeight / 60;
    const snapInterval = gridSettings.snapInterval;
    const dayStartHour = gridSettings.dayStartHour;
    
    // Calculate total minutes from day start
    let totalMinutes = Math.floor(y / minuteHeight);
    
    // Snap to interval
    totalMinutes = Math.round(totalMinutes / snapInterval) * snapInterval;
    
    // Add day start offset
    totalMinutes += dayStartHour * 60;
    
    return {
      minutes: totalMinutes,
      time: this.minutesToTime(totalMinutes),
      y: y
    };
  }

  /**
   * Scroll to specific hour
   */
  scrollToHour(hour: number): void {
    if (!this.grid) return;
    
    const gridSettings = calendarConfig.getGridSettings();
    const hourHeight = gridSettings.hourHeight;
    const dayStartHour = gridSettings.dayStartHour;
    const headerHeight = 80; // Header row height
    const scrollTop = headerHeight + ((hour - dayStartHour) * hourHeight);
    
    this.grid.scrollTop = scrollTop;
  }

  /**
   * Utility methods
   */
  
  private minutesToTime(totalMinutes: number): string {
    const hours = Math.floor(totalMinutes / 60);
    const minutes = totalMinutes % 60;
    const period = hours >= 12 ? 'PM' : 'AM';
    const displayHour = hours > 12 ? hours - 12 : (hours === 0 ? 12 : hours);
    
    return `${displayHour}:${minutes.toString().padStart(2, '0')} ${period}`;
  }
}