import { EventBus } from '../core/EventBus';
import { IEventBus, CalendarEvent, ResourceCalendarData } from '../types/CalendarTypes';
import { EventTypes } from '../constants/EventTypes';
import { calendarConfig } from '../core/CalendarConfig';

/**
 * EventManager - Administrerer event lifecycle og CRUD operationer
 * Håndterer mock data og event synchronization
 */
export class EventManager {
    private eventBus: IEventBus;
    private events: CalendarEvent[] = [];

    constructor(eventBus: IEventBus) {
        console.log('EventManager: Constructor called');
        this.eventBus = eventBus;
        this.setupEventListeners();
        console.log('EventManager: About to call loadMockData()');
        this.loadMockData().then(() => {
            console.log('EventManager: loadMockData() completed, syncing events');
            // Data loaded, sync events after loading
            this.syncEvents();
        }).catch(error => {
            console.error('EventManager: loadMockData() failed:', error);
        });
    }

    private setupEventListeners(): void {
        this.eventBus.on(EventTypes.CALENDAR_INITIALIZED, () => {
            this.syncEvents();
        });

        this.eventBus.on(EventTypes.DATE_CHANGED, () => {
            this.syncEvents();
        });

        this.eventBus.on(EventTypes.VIEW_RENDERED, () => {
            this.syncEvents();
        });
    }

    private async loadMockData(): Promise<void> {
        try {
            const calendarType = calendarConfig.getCalendarType();
            let jsonFile: string;
            
            console.log(`EventManager: Calendar type detected: '${calendarType}'`);
            
            if (calendarType === 'resource') {
                jsonFile = '/src/data/mock-resource-events.json';
            } else {
                jsonFile = '/src/data/mock-events.json';
            }
            
            console.log(`EventManager: Loading ${calendarType} calendar data from ${jsonFile}`);
            
            const response = await fetch(jsonFile);
            if (!response.ok) {
                throw new Error(`Failed to load mock events: ${response.status}`);
            }
            
            if (calendarType === 'resource') {
                const resourceData: ResourceCalendarData = await response.json();
                // Flatten events from all resources and add resource metadata
                this.events = resourceData.resources.flatMap(resource => 
                    resource.events.map(event => ({
                        ...event,
                        resourceName: resource.name,
                        resourceDisplayName: resource.displayName,
                        resourceEmployeeId: resource.employeeId
                    }))
                );
                console.log(`EventManager: Loaded ${this.events.length} events from ${resourceData.resources.length} resources`);
                
                // Emit resource data for GridManager
                this.eventBus.emit(EventTypes.RESOURCE_DATA_LOADED, {
                    resourceData: resourceData
                });
            } else {
                this.events = await response.json();
                console.log(`EventManager: Loaded ${this.events.length} date calendar events`);
            }
            
            console.log('EventManager: First event:', this.events[0]);
            console.log('EventManager: Last event:', this.events[this.events.length - 1]);
        } catch (error) {
            console.error('EventManager: Failed to load mock events:', error);
            this.events = []; // Fallback to empty array
        }
    }

    private syncEvents(): void {
        // Emit events for rendering
        this.eventBus.emit(EventTypes.EVENTS_LOADED, {
            events: this.events
        });

        console.log(`EventManager: Synced ${this.events.length} events`);
    }

    public getEvents(): CalendarEvent[] {
        return [...this.events];
    }


    public getEventById(id: string): CalendarEvent | undefined {
        return this.events.find(event => event.id === id);
    }

    public addEvent(event: Omit<CalendarEvent, 'id'>): CalendarEvent {
        const newEvent: CalendarEvent = {
            ...event,
            id: Date.now().toString()
        };
        
        this.events.push(newEvent);
        this.syncEvents();
        
        this.eventBus.emit(EventTypes.EVENT_CREATED, {
            event: newEvent
        });

        return newEvent;
    }

    public updateEvent(id: string, updates: Partial<CalendarEvent>): CalendarEvent | null {
        const eventIndex = this.events.findIndex(event => event.id === id);
        if (eventIndex === -1) return null;

        const updatedEvent = { ...this.events[eventIndex], ...updates };
        this.events[eventIndex] = updatedEvent;
        
        this.syncEvents();
        
        this.eventBus.emit(EventTypes.EVENT_UPDATED, {
            event: updatedEvent
        });

        return updatedEvent;
    }

    public deleteEvent(id: string): boolean {
        const eventIndex = this.events.findIndex(event => event.id === id);
        if (eventIndex === -1) return false;

        const deletedEvent = this.events[eventIndex];
        this.events.splice(eventIndex, 1);
        
        this.syncEvents();
        
        this.eventBus.emit(EventTypes.EVENT_DELETED, {
            event: deletedEvent
        });

        return true;
    }

    public refresh(): void {
        this.syncEvents();
    }

    public destroy(): void {
        this.events = [];
    }
}