// static/admin/js/marketplace-products.js
/**
 * Admin marketplace products page logic
 * Browse the master product repository (imported from external sources)
 */

const adminMarketplaceProductsLog = window.LogConfig.loggers.adminMarketplaceProducts ||
    window.LogConfig.createLogger('adminMarketplaceProducts', false);

adminMarketplaceProductsLog.info('Loading...');

function adminMarketplaceProducts() {
    adminMarketplaceProductsLog.info('adminMarketplaceProducts() called');

    return {
        // Inherit base layout state
        ...data(),

        // Set page identifier
        currentPage: 'marketplace-products',

        // Loading states
        loading: true,
        error: '',

        // Products data
        products: [],
        stats: {
            total: 0,
            active: 0,
            inactive: 0,
            digital: 0,
            physical: 0,
            by_marketplace: {}
        },

        // Filters
        filters: {
            search: '',
            marketplace: '',
            vendor_name: '',
            is_active: '',
            is_digital: ''
        },

        // Available marketplaces for filter dropdown
        marketplaces: [],

        // Available source vendors for filter dropdown
        sourceVendors: [],

        // Pagination
        pagination: {
            page: 1,
            per_page: 50,
            total: 0,
            pages: 0
        },

        // Selection state
        selectedProducts: [],

        // Copy to vendor modal state
        showCopyModal: false,
        copying: false,
        copyForm: {
            vendor_id: '',
            skip_existing: true
        },
        targetVendors: [],

        // Debounce timer
        searchTimeout: null,

        // Computed: Total pages
        get totalPages() {
            return this.pagination.pages;
        },

        // Computed: Start index for pagination display
        get startIndex() {
            if (this.pagination.total === 0) return 0;
            return (this.pagination.page - 1) * this.pagination.per_page + 1;
        },

        // Computed: End index for pagination display
        get endIndex() {
            const end = this.pagination.page * this.pagination.per_page;
            return end > this.pagination.total ? this.pagination.total : end;
        },

        // Computed: Page numbers for pagination
        get pageNumbers() {
            const pages = [];
            const totalPages = this.totalPages;
            const current = this.pagination.page;

            if (totalPages <= 7) {
                for (let i = 1; i <= totalPages; i++) {
                    pages.push(i);
                }
            } else {
                pages.push(1);
                if (current > 3) {
                    pages.push('...');
                }
                const start = Math.max(2, current - 1);
                const end = Math.min(totalPages - 1, current + 1);
                for (let i = start; i <= end; i++) {
                    pages.push(i);
                }
                if (current < totalPages - 2) {
                    pages.push('...');
                }
                pages.push(totalPages);
            }
            return pages;
        },

        async init() {
            adminMarketplaceProductsLog.info('Marketplace Products init() called');

            // Guard against multiple initialization
            if (window._adminMarketplaceProductsInitialized) {
                adminMarketplaceProductsLog.warn('Already initialized, skipping');
                return;
            }
            window._adminMarketplaceProductsInitialized = true;

            // Load data in parallel
            await Promise.all([
                this.loadStats(),
                this.loadMarketplaces(),
                this.loadSourceVendors(),
                this.loadTargetVendors(),
                this.loadProducts()
            ]);

            adminMarketplaceProductsLog.info('Marketplace Products initialization complete');
        },

        /**
         * Load product statistics
         */
        async loadStats() {
            try {
                const response = await apiClient.get('/admin/products/stats');
                this.stats = response;
                adminMarketplaceProductsLog.info('Loaded stats:', this.stats);
            } catch (error) {
                adminMarketplaceProductsLog.error('Failed to load stats:', error);
            }
        },

        /**
         * Load available marketplaces for filter
         */
        async loadMarketplaces() {
            try {
                const response = await apiClient.get('/admin/products/marketplaces');
                this.marketplaces = response.marketplaces || [];
                adminMarketplaceProductsLog.info('Loaded marketplaces:', this.marketplaces);
            } catch (error) {
                adminMarketplaceProductsLog.error('Failed to load marketplaces:', error);
            }
        },

        /**
         * Load available source vendors for filter (from marketplace products)
         */
        async loadSourceVendors() {
            try {
                const response = await apiClient.get('/admin/products/vendors');
                this.sourceVendors = response.vendors || [];
                adminMarketplaceProductsLog.info('Loaded source vendors:', this.sourceVendors);
            } catch (error) {
                adminMarketplaceProductsLog.error('Failed to load source vendors:', error);
            }
        },

        /**
         * Load target vendors for copy functionality (actual vendor accounts)
         */
        async loadTargetVendors() {
            try {
                const response = await apiClient.get('/admin/vendors?is_active=true&limit=500');
                this.targetVendors = response.vendors || [];
                adminMarketplaceProductsLog.info('Loaded target vendors:', this.targetVendors.length);
            } catch (error) {
                adminMarketplaceProductsLog.error('Failed to load target vendors:', error);
            }
        },

        /**
         * Load products with filtering and pagination
         */
        async loadProducts() {
            this.loading = true;
            this.error = '';

            try {
                const params = new URLSearchParams({
                    skip: (this.pagination.page - 1) * this.pagination.per_page,
                    limit: this.pagination.per_page
                });

                // Add filters
                if (this.filters.search) {
                    params.append('search', this.filters.search);
                }
                if (this.filters.marketplace) {
                    params.append('marketplace', this.filters.marketplace);
                }
                if (this.filters.vendor_name) {
                    params.append('vendor_name', this.filters.vendor_name);
                }
                if (this.filters.is_active !== '') {
                    params.append('is_active', this.filters.is_active);
                }
                if (this.filters.is_digital !== '') {
                    params.append('is_digital', this.filters.is_digital);
                }

                const response = await apiClient.get(`/admin/products?${params.toString()}`);

                this.products = response.products || [];
                this.pagination.total = response.total || 0;
                this.pagination.pages = Math.ceil(this.pagination.total / this.pagination.per_page);

                adminMarketplaceProductsLog.info('Loaded products:', this.products.length, 'of', this.pagination.total);
            } catch (error) {
                adminMarketplaceProductsLog.error('Failed to load products:', error);
                this.error = error.message || 'Failed to load products';
            } finally {
                this.loading = false;
            }
        },

        /**
         * Debounced search handler
         */
        debouncedSearch() {
            clearTimeout(this.searchTimeout);
            this.searchTimeout = setTimeout(() => {
                this.pagination.page = 1;
                this.loadProducts();
            }, 300);
        },

        /**
         * Refresh products list
         */
        async refresh() {
            await Promise.all([
                this.loadStats(),
                this.loadProducts()
            ]);
        },

        // ─────────────────────────────────────────────────────────────────
        // Selection Management
        // ─────────────────────────────────────────────────────────────────

        /**
         * Check if a product is selected
         */
        isSelected(productId) {
            return this.selectedProducts.includes(productId);
        },

        /**
         * Toggle selection for a single product
         */
        toggleSelection(productId) {
            const index = this.selectedProducts.indexOf(productId);
            if (index === -1) {
                this.selectedProducts.push(productId);
            } else {
                this.selectedProducts.splice(index, 1);
            }
            adminMarketplaceProductsLog.info('Selection changed:', this.selectedProducts.length, 'selected');
        },

        /**
         * Toggle select all products on current page
         */
        toggleSelectAll(event) {
            if (event.target.checked) {
                // Select all on current page
                this.selectedProducts = this.products.map(p => p.id);
            } else {
                // Deselect all
                this.selectedProducts = [];
            }
            adminMarketplaceProductsLog.info('Select all toggled:', this.selectedProducts.length, 'selected');
        },

        /**
         * Clear all selections
         */
        clearSelection() {
            this.selectedProducts = [];
            adminMarketplaceProductsLog.info('Selection cleared');
        },

        // ─────────────────────────────────────────────────────────────────
        // Copy to Vendor Catalog
        // ─────────────────────────────────────────────────────────────────

        /**
         * Open copy modal for selected products
         */
        openCopyToVendorModal() {
            if (this.selectedProducts.length === 0) {
                this.error = 'Please select at least one product to copy';
                return;
            }
            this.copyForm.vendor_id = '';
            this.showCopyModal = true;
            adminMarketplaceProductsLog.info('Opening copy modal for', this.selectedProducts.length, 'products');
        },

        /**
         * Copy single product - convenience method for action button
         */
        copySingleProduct(productId) {
            this.selectedProducts = [productId];
            this.openCopyToVendorModal();
        },

        /**
         * Execute copy to vendor catalog
         */
        async executeCopyToVendor() {
            if (!this.copyForm.vendor_id) {
                this.error = 'Please select a target vendor';
                return;
            }

            this.copying = true;
            try {
                const response = await apiClient.post('/admin/products/copy-to-vendor', {
                    marketplace_product_ids: this.selectedProducts,
                    vendor_id: parseInt(this.copyForm.vendor_id),
                    skip_existing: this.copyForm.skip_existing
                });

                adminMarketplaceProductsLog.info('Copy result:', response);

                // Show success message
                const copied = response.copied || 0;
                const skipped = response.skipped || 0;
                const failed = response.failed || 0;

                let message = `Successfully copied ${copied} product(s) to vendor catalog.`;
                if (skipped > 0) message += ` ${skipped} already existed.`;
                if (failed > 0) message += ` ${failed} failed.`;

                // Close modal and clear selection
                this.showCopyModal = false;
                this.clearSelection();

                // Show success notification
                Utils.showToast(message, 'success');
            } catch (error) {
                adminMarketplaceProductsLog.error('Failed to copy products:', error);
                const errorMsg = error.message || 'Failed to copy products to vendor catalog';
                this.error = errorMsg;
                Utils.showToast(errorMsg, 'error');
            } finally {
                this.copying = false;
            }
        },

        /**
         * Format price for display
         */
        formatPrice(price, currency = 'EUR') {
            if (price === null || price === undefined) return '-';
            return new Intl.NumberFormat('en-US', {
                style: 'currency',
                currency: currency || 'EUR'
            }).format(price);
        },

        /**
         * Pagination: Previous page
         */
        previousPage() {
            if (this.pagination.page > 1) {
                this.pagination.page--;
                this.loadProducts();
            }
        },

        /**
         * Pagination: Next page
         */
        nextPage() {
            if (this.pagination.page < this.totalPages) {
                this.pagination.page++;
                this.loadProducts();
            }
        },

        /**
         * Pagination: Go to specific page
         */
        goToPage(pageNum) {
            if (pageNum !== '...' && pageNum >= 1 && pageNum <= this.totalPages) {
                this.pagination.page = pageNum;
                this.loadProducts();
            }
        }
    };
}
