/**
 * ================================================
 * ESTREKA KALENDRI FRONTEND JAVASCRIPT
 * ================================================
 * 
 * Funktsioonid:
 * - FullCalendar.js integratsioon
 * - Sündmuste CRUD operatsioonid
 * - Drag & drop sündmuste liigutamine
 * - Modal dialoogid
 * - Kategooriate filtreerimine
 * - Meeldetuletuste haldus
 * 
 * EELDUSED:
 * - FullCalendar.js peab olema laaditud
 * - jQuery või vanilla JS
 * - Bootstrap Modal (valikuline)
 * 
 * ================================================
 */

class EstrekaCalendar {
    constructor(options = {}) {
        this.options = {
            containerId: 'calendar-grid',
            apiBaseUrl: 'calendar/api/',  // RELATIVE URL - CSP compatible
            defaultView: 'dayGridMonth',
            locale: 'et',
            ...options
        };
        
        this.calendar = null;
        this.currentEvents = [];
        this.categories = [];
        this.filteredCategories = new Set();
        
        this.init();
    }
    
    /**
     * Initsialiseerime kalendri
     */
    init() {
        console.log('🚀 EstrekaCalendar initializing...');
        
        // Laadi kategooriad
        this.loadCategories()
            .then(() => {
                // Initsialiseerib FullCalendar
                this.initializeFullCalendar();
                
                // Seo event listenerid
                this.bindEventListeners();
                
                console.log('✅ EstrekaCalendar ready!');
            })
            .catch(error => {
                console.error('❌ Calendar initialization failed:', error);
                this.showError('Kalendri laadimisel tekkis viga');
            });
    }
    
    /**
     * FullCalendar initsialiseermine
     */
    initializeFullCalendar() {
        const calendarEl = document.getElementById(this.options.containerId);
        
        if (!calendarEl) {
            throw new Error('Calendar container not found');
        }
        
        // FullCalendar konfiguratsioon
        this.calendar = new FullCalendar.Calendar(calendarEl, {
            // Põhiseadistused
            initialView: this.options.defaultView,
            locale: this.options.locale,
            headerToolbar: {
                left: 'prev,next today',
                center: 'title',
                right: 'dayGridMonth,timeGridWeek,timeGridDay,listWeek'
            },
            buttonText: {
                today: 'Täna',
                month: 'Kuu',
                week: 'Nädal', 
                day: 'Päev',
                list: 'Nimekiri'
            },
            
            // Ajaseadistused
            slotMinTime: '06:00:00',
            slotMaxTime: '24:00:00',
            slotDuration: '00:30:00',
            scrollTime: '08:00:00',
            
            // Sündmused
            events: (info, successCallback, failureCallback) => {
                this.loadEvents(info.start, info.end)
                    .then(events => successCallback(events))
                    .catch(error => failureCallback(error));
            },
            
            // Sündmuse klõps
            eventClick: (info) => {
                this.handleEventClick(info);
            },
            
            // Kuupäeva klõps - uue sündmuse loomine
            dateClick: (info) => {
                this.handleDateClick(info);
            },
            
            // Drag & drop
            editable: true,
            droppable: true,
            
            // Sündmuse liigutamine
            eventDrop: (info) => {
                this.handleEventDrop(info);
            },
            
            // Sündmuse suuruse muutmine
            eventResize: (info) => {
                this.handleEventResize(info);
            },
            
            // Kuupäeva vahemiku valimine
            selectable: true,
            selectMirror: true,
            select: (info) => {
                this.handleDateSelect(info);
            },
            
            // Sündmuse kuvamise konfiguratsioon
            eventDisplay: 'block',
            dayMaxEvents: 3,
            moreLinkClick: 'popover',
            
            // Nädalavaate seadistused
            allDaySlot: true,
            allDayText: 'Kogu päev',
            
            // Sündmuse tooltip
            eventMouseEnter: (info) => {
                this.showEventTooltip(info);
            },
            
            eventMouseLeave: (info) => {
                this.hideEventTooltip(info);
            }
        });
        
        // Renderi kalender
        this.calendar.render();
    }
    
    /**
     * Event listeneride sidumine
     */
    bindEventListeners() {
        // Uue sündmuse nupp
        const addEventBtn = document.getElementById('add-event-btn');
        if (addEventBtn) {
            addEventBtn.addEventListener('click', () => this.openEventModal());
        }
        
        // Vaate lülitamine
        document.querySelectorAll('[data-view]').forEach(btn => {
            btn.addEventListener('click', (e) => {
                const view = e.target.dataset.view;
                this.changeView(view);
                
                // Aktiivsuse märkimine
                document.querySelectorAll('[data-view]').forEach(b => b.classList.remove('active'));
                e.target.classList.add('active');
            });
        });
        
        // Kategooriate filtreerimine
        document.querySelectorAll('[data-category]').forEach(checkbox => {
            checkbox.addEventListener('change', (e) => {
                this.toggleCategoryFilter(e.target.dataset.category, e.target.checked);
            });
        });
        
        // Otsinguvorm
        const searchInput = document.getElementById('event-search');
        if (searchInput) {
            let searchTimeout;
            searchInput.addEventListener('input', (e) => {
                clearTimeout(searchTimeout);
                searchTimeout = setTimeout(() => {
                    this.searchEvents(e.target.value);
                }, 300);
            });
        }
        
        // Modal sündmused
        this.bindModalListeners();
        
        // Klaviatuuri lühikesed
        document.addEventListener('keydown', (e) => {
            this.handleKeyboardShortcuts(e);
        });
    }
    
    /**
     * Modal dialoogide seadistamine
     */
    bindModalListeners() {
        // Modal sulgemine
        document.addEventListener('click', (e) => {
            if (e.target.classList.contains('modal-overlay')) {
                this.closeEventModal();
            }
        });
        
        document.addEventListener('keydown', (e) => {
            if (e.key === 'Escape') {
                this.closeEventModal();
            }
        });
        
        // Sündmuse salvestamise vorm
        const eventForm = document.getElementById('event-form');
        if (eventForm) {
            eventForm.addEventListener('submit', (e) => {
                e.preventDefault();
                this.handleEventFormSubmit(new FormData(eventForm));
            });
        }
        
        // Modal sulgemise nupp
        const closeBtn = document.querySelector('.modal-close');
        if (closeBtn) {
            closeBtn.addEventListener('click', () => this.closeEventModal());
        }
    }
    
    /**
     * ==========================================
     * ANDMETE LAADIMINE
     * ==========================================
     */
    
    /**
     * Kategooriate laadimine
     */
    async loadCategories() {
        try {
            // Use relative URL to avoid CSP issues
            const response = await fetch(this.options.apiBaseUrl + 'categories.php');
            
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (!data.success) {
                throw new Error(data.error || 'Kategooriate laadimine ebaõnnestus');
            }
            
            this.categories = data.data;
            this.updateCategoryFilter();
            
            console.log('📂 Categories loaded:', this.categories.length);
            
        } catch (error) {
            console.error('❌ Error loading categories:', error);
            // Fallback to embedded data if available
            if (window.calendarData && window.calendarData.categories) {
                console.log('📂 Using fallback categories from embedded data');
                this.categories = window.calendarData.categories;
                this.updateCategoryFilter();
            } else {
                throw error;
            }
        }
    }
    
    /**
     * Sündmuste laadimine
     */
    async loadEvents(start, end) {
        try {
            const startDate = start.toISOString().split('T')[0];
            const endDate = end.toISOString().split('T')[0];
            
            // Use relative URL to avoid CSP issues
            const url = this.options.apiBaseUrl + `events.php?action=list&start=${startDate}&end=${endDate}`;
            const response = await fetch(url);
            
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (!data.success) {
                throw new Error(data.error || 'Sündmuste laadimine ebaõnnestus');
            }
            
            this.currentEvents = data.data;
            
            // Filtreeri kategooriate järgi
            const filteredEvents = this.filterEventsByCategory(this.currentEvents);
            
            console.log('📅 Events loaded:', filteredEvents.length);
            
            return filteredEvents;
            
        } catch (error) {
            console.error('❌ Error loading events:', error);
            // Fallback to embedded data if available
            if (window.calendarData && window.calendarData.events) {
                console.log('📅 Using fallback events from embedded data');
                this.currentEvents = window.calendarData.events;
                return this.filterEventsByCategory(this.currentEvents);
            } else {
                this.showError('Sündmuste laadimisel tekkis viga');
                return [];
            }
        }
    }
    
    /**
     * ==========================================
     * SÜNDMUSTE KÄSITSEMINE
     * ==========================================
     */
    
    /**
     * Sündmuse klõps
     */
    handleEventClick(info) {
        const event = info.event;
        const eventData = {
            id: event.id,
            title: event.title,
            start: event.start,
            end: event.end,
            allDay: event.allDay,
            ...event.extendedProps
        };
        
        this.openEventModal(eventData);
    }
    
    /**
     * Kuupäeva klõps
     */
    handleDateClick(info) {
        const eventData = {
            start: info.date,
            allDay: info.allDay
        };
        
        this.openEventModal(eventData);
    }
    
    /**
     * Kuupäeva vahemiku valimine
     */
    handleDateSelect(info) {
        const eventData = {
            start: info.start,
            end: info.end,
            allDay: info.allDay
        };
        
        this.openEventModal(eventData);
        this.calendar.unselect();
    }
    
    /**
     * Sündmuse liigutamine (drag & drop)
     */
    async handleEventDrop(info) {
        const event = info.event;
        
        try {
            const updateData = {
                id: event.id,
                start_datetime: this.formatDateTime(event.start),
                end_datetime: event.end ? this.formatDateTime(event.end) : null,
                all_day: event.allDay
            };
            
            await this.updateEvent(updateData);
            
            this.showSuccess('Sündmus edukalt liigutatud!');
            
        } catch (error) {
            console.error('❌ Error moving event:', error);
            info.revert(); // Taasta algne asukoht
            this.showError('Sündmuse liigutamisel tekkis viga');
        }
    }
    
    /**
     * Sündmuse suuruse muutmine
     */
    async handleEventResize(info) {
        const event = info.event;
        
        try {
            const updateData = {
                id: event.id,
                end_datetime: this.formatDateTime(event.end)
            };
            
            await this.updateEvent(updateData);
            
            this.showSuccess('Sündmuse kestus muudetud!');
            
        } catch (error) {
            console.error('❌ Error resizing event:', error);
            info.revert(); // Taasta algne suurus
            this.showError('Sündmuse muutmisel tekkis viga');
        }
    }
    
    /**
     * ==========================================
     * CRUD OPERATSIOONID
     * ==========================================
     */
    
    /**
     * Loo uus sündmus
     */
    async createEvent(eventData) {
        try {
            const response = await fetch(this.options.apiBaseUrl + 'events.php', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(eventData)
            });
            
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (!data.success) {
                throw new Error(data.error || 'Sündmuse loomine ebaõnnestus');
            }
            
            // Uuenda kalendrit
            if (this.calendar) {
                this.calendar.refetchEvents();
            }
            
            this.showSuccess('Sündmus edukalt loodud!');
            
            return data.data;
            
        } catch (error) {
            console.error('❌ Error creating event:', error);
            throw error;
        }
    }
    
    /**
     * Uuenda sündmust
     */
    async updateEvent(eventData) {
        try {
            const response = await fetch(this.options.apiBaseUrl + 'events.php', {
                method: 'PUT',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify(eventData)
            });
            
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (!data.success) {
                throw new Error(data.error || 'Sündmuse uuendamine ebaõnnestus');
            }
            
            // Uuenda kalendrit
            if (this.calendar) {
                this.calendar.refetchEvents();
            }
            
            return data.data;
            
        } catch (error) {
            console.error('❌ Error updating event:', error);
            throw error;
        }
    }
    
    /**
     * Kustuta sündmus
     */
    async deleteEvent(eventId) {
        if (!confirm('Kas oled kindel, et soovid selle sündmuse kustutada?')) {
            return;
        }
        
        try {
            const response = await fetch(this.options.apiBaseUrl + 'events.php', {
                method: 'DELETE',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ id: eventId })
            });
            
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (!data.success) {
                throw new Error(data.error || 'Sündmuse kustutamine ebaõnnestus');
            }
            
            // Uuenda kalendrit
            if (this.calendar) {
                this.calendar.refetchEvents();
            }
            
            this.showSuccess('Sündmus edukalt kustutatud!');
            
        } catch (error) {
            console.error('❌ Error deleting event:', error);
            this.showError('Sündmuse kustutamisel tekkis viga');
        }
    }
    
    /**
     * ==========================================
     * MODAL DIALOOGID
     * ==========================================
     */
    
    /**
     * Ava sündmuse modal
     */
    openEventModal(eventData = null) {
        const modal = document.getElementById('eventModal');
        if (!modal) {
            console.error('Event modal not found');
            return;
        }
        
        // Täida vorm andmetega
        this.populateEventForm(eventData);
        
        // Näita modali
        modal.style.display = 'flex';
        document.body.style.overflow = 'hidden';
        
        // Fookus esimesele väljale
        const titleInput = document.getElementById('event-title');
        if (titleInput) {
            titleInput.focus();
        }
    }
    
    /**
     * Sulge modal
     */
    closeEventModal() {
        const modal = document.getElementById('eventModal');
        if (modal) {
            modal.style.display = 'none';
            document.body.style.overflow = '';
        }
        
        // Puhasta vorm
        this.clearEventForm();
    }
    
    /**
     * Täida sündmuse vorm
     */
    populateEventForm(eventData) {
        const form = document.getElementById('event-form');
        if (!form) return;
        
        // Puhasta vorm
        form.reset();
        
        if (eventData) {
            // ID (varjatud väli muutmiseks)
            const idInput = document.getElementById('event-id');
            if (idInput) {
                idInput.value = eventData.id || '';
            }
            
            // Pealkiri
            const titleInput = document.getElementById('event-title');
            if (titleInput) {
                titleInput.value = eventData.title || '';
            }
            
            // Kirjeldus
            const descInput = document.getElementById('event-description');
            if (descInput) {
                descInput.value = eventData.description || '';
            }
            
            // Algusaeg
            const startInput = document.getElementById('event-start');
            if (startInput && eventData.start) {
                startInput.value = this.formatDateTimeForInput(eventData.start);
            }
            
            // Lõppaeg
            const endInput = document.getElementById('event-end');
            if (endInput && eventData.end) {
                endInput.value = this.formatDateTimeForInput(eventData.end);
            }
            
            // Kogu päev
            const allDayInput = document.getElementById('event-all-day');
            if (allDayInput) {
                allDayInput.checked = eventData.allDay || false;
            }
            
            // Kategooria
            const categoryInput = document.getElementById('event-category');
            if (categoryInput) {
                categoryInput.value = eventData.category_id || '';
            }
            
            // Asukoht
            const locationInput = document.getElementById('event-location');
            if (locationInput) {
                locationInput.value = eventData.location || '';
            }
        }
        
        // Uuenda kategooriate rippmenüüd
        this.updateCategorySelect();
    }
    
    /**
     * Puhasta sündmuse vorm
     */
    clearEventForm() {
        const form = document.getElementById('event-form');
        if (form) {
            form.reset();
        }
    }
    
    /**
     * Käsitle sündmuse vormi esitamist
     */
    async handleEventFormSubmit(formData) {
        try {
            // Kogu andmed vormist
            const eventData = {
                title: formData.get('title'),
                description: formData.get('description'),
                start_datetime: formData.get('start_datetime'),
                end_datetime: formData.get('end_datetime'),
                all_day: formData.get('all_day') === 'on',
                category_id: formData.get('category_id') || null,
                location: formData.get('location')
            };
            
            const eventId = formData.get('id');
            
            if (eventId) {
                // Uuenda olemasolevat sündmust
                eventData.id = eventId;
                await this.updateEvent(eventData);
                this.showSuccess('Sündmus edukalt uuendatud!');
            } else {
                // Loo uus sündmus
                await this.createEvent(eventData);
                this.showSuccess('Sündmus edukalt loodud!');
            }
            
            // Sulge modal
            this.closeEventModal();
            
        } catch (error) {
            console.error('❌ Error submitting form:', error);
            this.showError(error.message || 'Sündmuse salvestamisel tekkis viga');
        }
    }
    
    /**
     * ==========================================
     * KATEGOORIATE FILTREERIMINE
     * ==========================================
     */
    
    /**
     * Kategooria filtri lülitamine
     */
    toggleCategoryFilter(categoryId, enabled) {
        if (enabled) {
            this.filteredCategories.delete(categoryId);
        } else {
            this.filteredCategories.add(categoryId);
        }
        
        // Uuenda kalendrit
        this.calendar.refetchEvents();
    }
    
    /**
     * Filtreeri sündmused kategooriate järgi
     */
    filterEventsByCategory(events) {
        if (this.filteredCategories.size === 0) {
            return events;
        }
        
        return events.filter(event => {
            return !this.filteredCategories.has(event.extendedProps?.category_id?.toString());
        });
    }
    
    /**
     * Uuenda kategooriate filtrit
     */
    updateCategoryFilter() {
        const container = document.querySelector('.category-list');
        if (!container) return;
        
        container.innerHTML = '';
        
        this.categories.forEach(category => {
            const item = document.createElement('label');
            item.className = 'category-item';
            
            item.innerHTML = `
                <input type="checkbox" checked data-category="${category.id}">
                <span class="category-color" style="background-color: ${category.color}"></span>
                <span class="category-icon">${category.icon}</span>
                <span class="category-name">${category.name}</span>
                <span class="category-count">${category.event_count || 0}</span>
            `;
            
            // Lisa event listener
            const checkbox = item.querySelector('input');
            checkbox.addEventListener('change', (e) => {
                this.toggleCategoryFilter(category.id, e.target.checked);
            });
            
            container.appendChild(item);
        });
    }
    
    /**
     * Uuenda kategooriate rippmenüüd
     */
    updateCategorySelect() {
        const select = document.getElementById('event-category');
        if (!select) return;
        
        // Säilita praegune valik
        const currentValue = select.value;
        
        select.innerHTML = '<option value="">Vali kategooria...</option>';
        
        this.categories.forEach(category => {
            const option = document.createElement('option');
            option.value = category.id;
            option.textContent = `${category.icon} ${category.name}`;
            select.appendChild(option);
        });
        
        // Taasta valik
        select.value = currentValue;
    }
    
    /**
     * ==========================================
     * OTSING JA NAVIGATSIOON
     * ==========================================
     */
    
    /**
     * Otsi sündmusi
     */
    async searchEvents(query) {
        if (!query.trim()) {
            if (this.calendar) {
                this.calendar.refetchEvents();
            }
            return;
        }
        
        try {
            const response = await fetch(this.options.apiBaseUrl + `events.php?action=search&q=${encodeURIComponent(query)}`);
            
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (!data.success) {
                throw new Error(data.error);
            }
            
            // Näita otsingutulemusi
            this.displaySearchResults(data.data);
            
        } catch (error) {
            console.error('❌ Search error:', error);
            this.showError('Otsimisel tekkis viga');
        }
    }
    
    /**
     * Muuda kalendri vaadet
     */
    changeView(viewName) {
        if (this.calendar) {
            this.calendar.changeView(viewName);
        }
    }
    
    /**
     * Klaviatuuri lühikesed
     */
    handleKeyboardShortcuts(e) {
        // Ctrl/Cmd + N = uus sündmus
        if ((e.ctrlKey || e.metaKey) && e.key === 'n') {
            e.preventDefault();
            this.openEventModal();
        }
        
        // T = täna
        if (e.key === 't' && !e.ctrlKey && !e.metaKey) {
            if (document.activeElement.tagName !== 'INPUT' && document.activeElement.tagName !== 'TEXTAREA') {
                this.calendar.today();
            }
        }
    }
    
    /**
     * ==========================================
     * ABIFUNKTSIOONID
     * ==========================================
     */
    
    /**
     * Kuupäeva formaatimine sisendi jaoks
     */
    formatDateTimeForInput(date) {
        const d = new Date(date);
        return d.toISOString().slice(0, 16);
    }
    
    /**
     * Kuupäeva formaatimine serverile saatmiseks
     */
    formatDateTime(date) {
        return new Date(date).toISOString().slice(0, 19).replace('T', ' ');
    }
    
    /**
     * Näita eduteadet
     */
    showSuccess(message) {
        this.showNotification(message, 'success');
    }
    
    /**
     * Näita veateadet
     */
    showError(message) {
        this.showNotification(message, 'error');
    }
    
    /**
     * Näita teatist
     */
    showNotification(message, type = 'info') {
        // Loo toast notification
        const toast = document.createElement('div');
        toast.className = `toast toast-${type}`;
        toast.textContent = message;
        
        // Lisa body-sse
        document.body.appendChild(toast);
        
        // Animatsioon
        setTimeout(() => toast.classList.add('show'), 100);
        
        // Eemalda pärast 3 sekundit
        setTimeout(() => {
            toast.classList.remove('show');
            setTimeout(() => document.body.removeChild(toast), 300);
        }, 3000);
    }
    
    /**
     * Näita sündmuse tooltipi
     */
    showEventTooltip(info) {
        // Implementeeri tooltip loogika
        const event = info.event;
        const tooltip = document.createElement('div');
        tooltip.className = 'event-tooltip';
        tooltip.innerHTML = `
            <strong>${event.title}</strong><br>
            ${event.start.toLocaleString()}<br>
            ${event.extendedProps.description || ''}
        `;
        
        document.body.appendChild(tooltip);
        
        // Positsiooni tooltip
        const rect = info.el.getBoundingClientRect();
        tooltip.style.left = rect.right + 10 + 'px';
        tooltip.style.top = rect.top + 'px';
    }
    
    /**
     * Peida tooltip
     */
    hideEventTooltip(info) {
        const tooltip = document.querySelector('.event-tooltip');
        if (tooltip) {
            document.body.removeChild(tooltip);
        }
    }
}

/**
 * ==========================================
 * AUTOMAATNE KÄIVITAMINE
 * ==========================================
 */

// Käivita kalender, kui DOM on laaditud
document.addEventListener('DOMContentLoaded', function() {
    // Kontrolli, kas FullCalendar on saadaval
    if (typeof FullCalendar === 'undefined') {
        console.error('❌ FullCalendar library not found! Please include FullCalendar.js');
        return;
    }
    
    // Kontrolli, kas kalendri konteiner eksisteerib
    if (!document.getElementById('calendar-grid')) {
        console.warn('⚠️ Calendar container not found, skipping initialization');
        return;
    }
    
    // Initsialiseerib kalendri
    window.estrekaCalendar = new EstrekaCalendar();
});

// Ekspordi klass globaalsesse scope'i
window.EstrekaCalendar = EstrekaCalendar;