Calendar/src/index.ts

// Main entry point for Calendar Plantempus
import { Container } from '@novadi/core';
import { eventBus } from './core/EventBus';
import { calendarConfig } from './core/CalendarConfig';
import { URLManager } from './utils/URLManager';
import { IEventBus } from './types/CalendarTypes';

// Import all managers
import { EventManager } from './managers/EventManager';
import { EventRenderingService } from './renderers/EventRendererManager';
import { GridManager } from './managers/GridManager';
import { ScrollManager } from './managers/ScrollManager';
import { NavigationManager } from './managers/NavigationManager';
import { ViewManager } from './managers/ViewManager';
import { CalendarManager } from './managers/CalendarManager';
import { DragDropManager } from './managers/DragDropManager';
import { AllDayManager } from './managers/AllDayManager';
import { ResizeHandleManager } from './managers/ResizeHandleManager';
import { EdgeScrollManager } from './managers/EdgeScrollManager';
import { DragHoverManager } from './managers/DragHoverManager';
import { HeaderManager } from './managers/HeaderManager';

// Import renderers
import { DateHeaderRenderer, type HeaderRenderer } from './renderers/HeaderRenderer';
import { DateColumnRenderer, type ColumnRenderer } from './renderers/ColumnRenderer';
import { DateEventRenderer, type EventRendererStrategy } from './renderers/EventRenderer';
import { GridRenderer } from './renderers/GridRenderer';

/**
 * Handle deep linking functionality after managers are initialized
 */
async function handleDeepLinking(eventManager: EventManager): Promise<void> {
  try {
    const urlManager = new URLManager(eventBus);
    const eventId = urlManager.parseEventIdFromURL();

    if (eventId) {
      console.log(`Deep linking to event ID: ${eventId}`);

      // Wait a bit for managers to be fully ready
      setTimeout(() => {
        const success = eventManager.navigateToEvent(eventId);
        if (!success) {
          console.warn(`Deep linking failed: Event with ID ${eventId} not found`);
        }
      }, 500);
    }
  } catch (error) {
    console.warn('Deep linking failed:', error);
  }
}

/**
 * Initialize the calendar application using NovaDI
 */
async function initializeCalendar(): Promise<void> {
  try {
    // Use the singleton calendar configuration
    const config = calendarConfig;

    // Create NovaDI container
    const container = new Container();
    const builder = container.builder();

    // Enable debug mode for development
    eventBus.setDebug(true);

    // Bind core services as instances
    builder.registerInstance(eventBus).as<IEventBus>();

    // Determine calendar mode and bind appropriate renderers
    const calendarMode = calendarConfig.getCalendarMode();
    console.log('🔧 DI Container: Calendar mode detected:', calendarMode);

    if (calendarMode === 'resource') {
      // Resource mode renderers
      console.log('🔧 DI Container: Binding DateHeaderRenderer for resource mode (TEST)');
      builder.registerInstance(new DateHeaderRenderer()).as<HeaderRenderer>();
      builder.registerInstance(new DateColumnRenderer()).as<ColumnRenderer>();
      builder.registerInstance(new DateEventRenderer()).as<EventRendererStrategy>();
    } else {
      // Date mode renderers (default)
      console.log('🔧 DI Container: Binding DateHeaderRenderer for date mode');
      builder.registerInstance(new DateHeaderRenderer()).as<HeaderRenderer>();
      builder.registerInstance(new DateColumnRenderer()).as<ColumnRenderer>();
      builder.registerInstance(new DateEventRenderer()).as<EventRendererStrategy>();
    }


    builder.registerType(EventRenderingService).as<EventRenderingService>().singleInstance();
    builder.registerType(GridRenderer).as<GridRenderer>().singleInstance();
    builder.registerType(GridManager).as<GridManager>().singleInstance();
    builder.registerType(ScrollManager).as<ScrollManager>().singleInstance();
    builder.registerType(NavigationManager).as<NavigationManager>().singleInstance();
    builder.registerType(ViewManager).as<ViewManager>().singleInstance();
    builder.registerType(DragDropManager).as<DragDropManager>().singleInstance();
    builder.registerType(AllDayManager).as<AllDayManager>().singleInstance();
    builder.registerType(ResizeHandleManager).as<ResizeHandleManager>().singleInstance();
    builder.registerType(EdgeScrollManager).as<EdgeScrollManager>().singleInstance();
    builder.registerType(DragHoverManager).as<DragHoverManager>().singleInstance();
    builder.registerType(HeaderManager).as<HeaderManager>().singleInstance();
    builder.registerType(CalendarManager).as<CalendarManager>().singleInstance();

    builder.registerType(EventManager).as<EventManager>().singleInstance();

    // Build the container
    const app = builder.build();

    // Get managers from container
    const eb = app.resolveType<IEventBus>();
    const calendarManager = app.resolveType<CalendarManager>();
    const eventManager = app.resolveType<EventManager>();
    const resizeHandleManager = app.resolveType<ResizeHandleManager>();
    const headerManager = app.resolveType<HeaderManager>();
    const dragDropManager = app.resolveType<DragDropManager>();
    const viewManager = app.resolveType<ViewManager>();
    const navigationManager = app.resolveType<NavigationManager>();
    const edgeScrollManager = app.resolveType<EdgeScrollManager>();
    const dragHoverManager = app.resolveType<DragHoverManager>();
    const allDayManager = app.resolveType<AllDayManager>();

    // Initialize managers
    await calendarManager.initialize?.();
    await resizeHandleManager.initialize?.();

    // Handle deep linking after managers are initialized
    await handleDeepLinking(eventManager);

    // Expose to window for debugging (with proper typing)
    (window as Window & {
      calendarDebug?: {
        eventBus: typeof eventBus;
        app: typeof app;
        calendarManager: typeof calendarManager;
        eventManager: typeof eventManager;
      };
    }).calendarDebug = {
      eventBus,
      app,
      calendarManager,
      eventManager,
    };

  } catch (error) {
    throw error;
  }
}

// Initialize when DOM is ready - now handles async properly
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', () => {
    initializeCalendar().catch(error => {
    });
  });
} else {
  initializeCalendar().catch(error => {
  });
}