// noqa: js-006 - async init pattern is safe, loadData has try/catch
// static/admin/js/dashboard.js

// ✅ Use centralized logger - ONE LINE!
const dashLog = window.LogConfig.loggers.dashboard;

function adminDashboard() {
    return {
        // Inherit base layout functionality from init-alpine.js
        ...data(),

        // Dashboard-specific state
        currentPage: 'dashboard',
        stats: {
            totalStores: 0,
            activeUsers: 0,
            verifiedStores: 0,
            importJobs: 0
        },
        recentStores: [],
        loading: true,
        error: null,

        /**
         * Initialize dashboard
         */
        async init() {
            // Load i18n translations
            await I18n.loadModule('core');

            // Guard against multiple initialization
            if (window._dashboardInitialized) {
                dashLog.warn('Dashboard already initialized, skipping...');
                return;
            }
            window._dashboardInitialized = true;

            dashLog.info('=== DASHBOARD INITIALIZING ===');
            dashLog.debug('Current URL:', window.location.href);
            dashLog.debug('Current pathname:', window.location.pathname);

            const token = localStorage.getItem('admin_token');
            dashLog.debug('Has admin_token?', !!token);
            if (token) {
                dashLog.debug('Token preview:', token.substring(0, 20) + '...');
            }
            dashLog.debug('Dashboard initialization flag set');

            const startTime = performance.now();
            await this.loadDashboard();
            const duration = performance.now() - startTime;

            window.LogConfig.logPerformance('Dashboard Init', duration);
            dashLog.info('=== DASHBOARD INITIALIZATION COMPLETE ===');
        },

        /**
         * Load all dashboard data
         */
        async loadDashboard() {
            dashLog.info('Loading dashboard data...');
            this.loading = true;
            this.error = null;
            dashLog.debug('Dashboard state: loading=true, error=null');

            try {
                dashLog.group('Loading dashboard data');
                const startTime = performance.now();

                // Load stats and stores in parallel
                await Promise.all([
                    this.loadStats(),
                    this.loadRecentStores()
                ]);

                const duration = performance.now() - startTime;
                dashLog.groupEnd();

                window.LogConfig.logPerformance('Load Dashboard Data', duration);
                dashLog.info(`Dashboard data loaded successfully in ${duration}ms`);

            } catch (error) {
                window.LogConfig.logError(error, 'Dashboard Load');
                this.error = error.message;
                Utils.showToast(I18n.t('core.messages.failed_to_load_dashboard_data'), 'error');

            } finally {
                this.loading = false;
                dashLog.debug('Dashboard state: loading=false');
                dashLog.info('Dashboard load attempt finished');
            }
        },

        /**
         * Load platform statistics
         */
        async loadStats() {
            dashLog.info('Loading platform statistics...');
            const url = '/admin/dashboard/stats/platform';

            window.LogConfig.logApiCall('GET', url, null, 'request');

            try {
                const startTime = performance.now();
                const data = await apiClient.get(url);
                const duration = performance.now() - startTime;

                window.LogConfig.logApiCall('GET', url, data, 'response');
                window.LogConfig.logPerformance('Load Stats', duration);

                // Map API response to stats cards
                this.stats = {
                    totalStores: data.stores?.total_stores || 0,
                    activeUsers: data.users?.active_users || 0,
                    verifiedStores: data.stores?.verified_stores || 0,
                    importJobs: data.imports?.total_imports || 0
                };

                dashLog.info('Stats mapped:', this.stats);

            } catch (error) {
                dashLog.error('Failed to load stats:', error);
                throw error;
            }
        },

        /**
         * Load recent stores
         */
        async loadRecentStores() {
            dashLog.info('Loading recent stores...');
            const url = '/admin/dashboard';

            window.LogConfig.logApiCall('GET', url, null, 'request');

            try {
                const startTime = performance.now();
                const data = await apiClient.get(url);
                const duration = performance.now() - startTime;

                window.LogConfig.logApiCall('GET', url, data, 'response');
                window.LogConfig.logPerformance('Load Recent Stores', duration);

                this.recentStores = data.recent_stores || [];

                if (this.recentStores.length > 0) {
                    dashLog.info(`Loaded ${this.recentStores.length} recent stores`);
                    dashLog.debug('First store:', this.recentStores[0]);
                } else {
                    dashLog.warn('No recent stores found');
                }

            } catch (error) {
                dashLog.error('Failed to load recent stores:', error);
                throw error;
            }
        },

        /**
         * Format date for display
         */
        formatDate(dateString) {
            if (!dateString) {
                dashLog.debug('formatDate called with empty dateString');
                return '-';
            }
            const formatted = Utils.formatDate(dateString);
            dashLog.debug(`Date formatted: ${dateString} -> ${formatted}`);
            return formatted;
        },

        /**
         * Navigate to store detail page
         */
        viewStore(storeCode) {
            dashLog.info('Navigating to store:', storeCode);
            const url = `/admin/stores?code=${storeCode}`;
            dashLog.debug('Navigation URL:', url);
            window.location.href = url;
        },

        /**
         * Refresh dashboard data
         */
        async refresh() {
            dashLog.info('=== DASHBOARD REFRESH TRIGGERED ===');
            await this.loadDashboard();
            Utils.showToast(I18n.t('core.messages.dashboard_refreshed'), 'success');
            dashLog.info('=== DASHBOARD REFRESH COMPLETE ===');
        }
    };
}

dashLog.info('Dashboard module loaded');
