{{-- 
    Export Excel Component
    
    Komponen JavaScript untuk export Excel dengan styling Framework MSJ
    - ExcelJS library integration (support styling)
    - SweetAlert2 notifications
    - Framework MSJ styling (#81E6D9)
    - Auto-size columns
    
    Usage:
    @include('components.export-excel')
    
    Requires: $exportHelper variable in controller
--}}

<script src="https://cdnjs.cloudflare.com/ajax/libs/exceljs/4.3.0/exceljs.min.js"></script>

<script>
// Inject PHP configuration to JavaScript
@if(isset($exportHelper))
window.ExportExcelConfig = {
    upload_bom: @json($exportHelper::getTableConfig('upload_bom')),
    recipe: @json($exportHelper::getTableConfig('recipe')),
    production_version: @json($exportHelper::getTableConfig('production_version'))
};
@endif
</script>

<script>
/**
 * Export table data to Excel with Framework MSJ styling
 * 
 * @param {string} tableId - HTML table ID
 * @param {string} filename - Output filename (without extension)
 * @param {function} validationCallback - Optional callback for custom row validation (for Upload BOM)
 *                                        Callback receives (rows, config, tableId) and returns {rows, exportedRowCount, groupBorders}
 * @param {boolean} showNotification - Show success/error notifications (default: true)
 * @return {Promise} Promise that resolves with export result
 */
async function exportTableToExcel(tableId, filename, validationCallback = null, showNotification = true, filterHeaderIds = null) {
    // Only show loading indicator if this is the first export (showNotification = true)
    if (showNotification) {
        Swal.fire({
            title: 'Mengekspor...',
            text: 'Mohon tunggu sementara kami menyiapkan file Excel Anda.',
            icon: 'info',
            allowOutsideClick: false,
            allowEscapeKey: false,
            showConfirmButton: false,
            didOpen: () => {
                Swal.showLoading()
            }
        });
    }

    return new Promise((resolve, reject) => {
        setTimeout(async () => {
            try {
                // Get table type from tableId
                const tableType = getTableTypeFromId(tableId);
                
                // Get table configuration from backend helper
                const config = getTableConfig(tableType);
                
                if (!config) {
                    throw new Error('Invalid table configuration');
                }
                
                // Extract data from table
                let { headers, rows, exportedRowCount } = extractTableData(tableId, config, filterHeaderIds);
                let groupBorders = [];
                
                // Apply custom validation if provided (for Upload BOM group validation)
                if (validationCallback && typeof validationCallback === 'function') {
                    const result = validationCallback(rows, config, tableId);
                    rows = result.rows;
                    exportedRowCount = result.exportedRowCount;
                    groupBorders = result.groupBorders || [];
                } else {
                    // For Recipe and PV: Each row is a separate header/group
                    // Generate group borders for each row
                    if (tableType === 'recipe' || tableType === 'production_version') {
                        groupBorders = rows.map((row, index) => ({
                            startRow: index + 2, // +2 because Excel is 1-indexed and has header row
                            endRow: index + 2    // Same row (single row per group)
                        }));
                    }
                }
                
                console.log('Group borders to apply:', groupBorders);
                
                // Validate data exists
                if (exportedRowCount === 0) {
                    if (showNotification) {
                        showNoDataWarning(tableType);
                    }
                    resolve({ success: false, exportedRowCount: 0, tableType });
                    return;
                }
                
                // Create Excel workbook with ExcelJS (pass groupBorders)
                await createWorkbookExcelJS(headers, rows, config, tableType, filename, groupBorders);
                
                // Only show success message if showNotification is true
                if (showNotification) {
                    showSuccessMessage(filename, exportedRowCount);
                }
                
                resolve({ success: true, exportedRowCount, tableType, filename });
                
            } catch (error) {
                console.error('Export error:', error);
                if (showNotification) {
                    showErrorMessage(error.message);
                }
                reject(error);
            }
        }, 1000);
    });
}

/**
 * Export multiple tables into a single Excel file with multiple sheets.
 */
async function exportMultipleTablesToExcel(exportsList, filename) {
    Swal.fire({
        title: 'Mengekspor...',
        text: 'Mohon tunggu sementara kami menyiapkan file Excel Anda.',
        icon: 'info',
        allowOutsideClick: false,
        allowEscapeKey: false,
        showConfirmButton: false,
        didOpen: () => {
            Swal.showLoading()
        }
    });

    return new Promise((resolve, reject) => {
        setTimeout(async () => {
            try {
                const workbook = new ExcelJS.Workbook();
                let totalExportedRows = 0;
                let hadData = false;

                for (const exportConfig of exportsList) {
                    const tableType = getTableTypeFromId(exportConfig.tableId);
                    const config = getTableConfig(tableType);
                    if (!config) continue;

                    let { headers, rows, exportedRowCount } = extractTableData(exportConfig.tableId, config, exportConfig.filterHeaderIds);
                    let groupBorders = [];

                    if (exportConfig.validationCallback && typeof exportConfig.validationCallback === 'function') {
                        const result = exportConfig.validationCallback(rows, config, exportConfig.tableId);
                        rows = result.rows;
                        exportedRowCount = result.exportedRowCount;
                        groupBorders = result.groupBorders || [];
                    } else {
                        if (tableType === 'recipe' || tableType === 'production_version') {
                            groupBorders = rows.map((row, index) => ({
                                startRow: index + 2,
                                endRow: index + 2
                            }));
                        }
                    }

                    if (exportedRowCount > 0) {
                        hadData = true;
                        totalExportedRows += exportedRowCount;
                        const worksheet = workbook.addWorksheet(exportConfig.sheetName || tableType);
                        
                        const headerRow = worksheet.addRow(headers);
                        headerRow.height = 30;
                        headerRow.eachCell((cell, colNumber) => {
                            const columnIndex = colNumber - 1;
                            const isHiddenColumn = config.hiddenColumns && config.hiddenColumns.includes(columnIndex);
                            cell.font = { bold: true, color: { argb: 'FF000000' }, size: 11 };
                            cell.fill = {
                                type: 'pattern',
                                pattern: 'solid',
                                fgColor: { argb: isHiddenColumn ? 'FFFFFF00' : 'FF81E6D9' }
                            };
                            cell.alignment = { horizontal: 'center', vertical: 'middle', wrapText: true };
                            cell.border = {
                                top: { style: 'thin', color: { argb: 'FF000000' } },
                                left: { style: 'thin', color: { argb: 'FF000000' } },
                                bottom: { style: 'thin', color: { argb: 'FF000000' } },
                                right: { style: 'thin', color: { argb: 'FF000000' } }
                            };
                        });

                        rows.forEach(row => worksheet.addRow(row));

                        // Apply Borders
                        if (groupBorders && groupBorders.length > 0) {
                            groupBorders.forEach(group => {
                                const startRow = group.startRow;
                                const endRow = group.endRow;
                                const lastCol = headers.length;
                                for (let r = startRow; r <= endRow; r++) {
                                    for (let c = 1; c <= lastCol; c++) {
                                        const cell = worksheet.getCell(r, c);
                                        if (!cell.border) cell.border = {};
                                        if (r === startRow) cell.border.top = { style: 'medium', color: { argb: 'FF000000' } };
                                        if (r === endRow) cell.border.bottom = { style: 'medium', color: { argb: 'FF000000' } };
                                        if (c === 1) cell.border.left = { style: 'medium', color: { argb: 'FF000000' } };
                                        if (c === lastCol) cell.border.right = { style: 'medium', color: { argb: 'FF000000' } };
                                    }
                                }
                            });
                        }

                        // Auto-size columns
                        worksheet.columns.forEach((column, index) => {
                            let maxLength = headers[index] ? headers[index].length : 10;
                            rows.forEach(row => {
                                const cellValue = row[index] ? row[index].toString() : '';
                                maxLength = Math.max(maxLength, cellValue.length);
                            });
                            if (config.columnWidths && config.columnWidths[index]) {
                                column.width = Math.max(maxLength + 2, config.columnWidths[index]);
                            } else {
                                column.width = Math.min(Math.max(maxLength + 2, 10), 50);
                            }
                            if (config.hiddenColumns && config.hiddenColumns.includes(index)) {
                                column.hidden = true;
                            }
                        });
                    }
                }

                if (!hadData) {
                    Swal.fire({
                        icon: 'warning',
                        title: 'Tidak Ada Data Terpilih',
                        text: 'Tidak ada data valid yang dapat diekspor.',
                        confirmButtonColor: '#ffc107'
                    });
                    resolve({ success: false, exportedRowCount: 0 });
                    return;
                }

                const buffer = await workbook.xlsx.writeBuffer();
                const blob = new Blob([buffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
                
                const url = window.URL.createObjectURL(blob);
                const link = document.createElement('a');
                link.href = url;
                link.download = filename + '.xlsx';
                link.click();
                resolve({ success: true, exportedRowCount: totalExportedRows, filename });
            } catch (error) {
                console.error('Export Multiple error:', error);
                showErrorMessage(error.message);
                reject(error);
            }
        }, 1000);
    });
}


/**
 * Get table type from HTML table ID
 */
function getTableTypeFromId(tableId) {
    const mapping = {
        'table_upload_bom': 'upload_bom',
        'table_recipe': 'recipe',
        'table_pv': 'production_version'
    };
    return mapping[tableId] || tableId;
}

/**
 * Get table configuration
 * Configuration is passed from backend ExportExcel_Helper via PHP
 */
function getTableConfig(tableType) {
    // Use configuration from PHP helper if available
    if (window.ExportExcelConfig && window.ExportExcelConfig[tableType]) {
        const phpConfig = window.ExportExcelConfig[tableType];
        
        // Convert PHP config format to JavaScript format
        return {
            headers: phpConfig.headers,
            selector: phpConfig.selector,
            specialColumns: phpConfig.special_columns || {},
            numericColumns: phpConfig.numeric_columns || [],
            hiddenColumns: phpConfig.hidden_columns || [],
            columnWidths: phpConfig.column_widths || {}
        };
    }
    
    // Fallback configuration (should not be used if PHP helper is properly configured)
    console.warn(`Using fallback configuration for ${tableType}. PHP helper not properly configured.`);
    
    const configs = {
        'upload_bom': {
            headers: [
                'Material FG/SFG', 'Header Description', 'Plant', 'Usage', 
                'Alternative BOM', 'Valid From', 'Alternative BOM Text', 
                'Product Qty', 'Base UOM Header', 'Item Number', 'Type', 
                'Component Material Code', 'Component Description', 'Component Qty', 'UOM'
            ],
            selector: '.upload-bom-checkbox',
            specialColumns: { 6: 'valid_from', 14: 'component_qty' },
            columnWidths: { 0: 20, 1: 45, 11: 20, 12: 45 }
        },
        'recipe': {
            headers: [
                'Kode Group', 'Plant (4)', 'Recipe Group (8)', 'Material', 'Description',
                'Recipe Description (40)', 'Recipe Counter (2)', 'Operation No. (4)', 'Phase', 'Rel', 'MOPER',
                'Resource (8)', 'Control Key', 'Description', 'Base QTY', 'UoM',
                'Charge', 'UOM charge', 'Operation', 'Setup', 'UoM Setup',
                'DLBC', 'UoM DLBC', 'DEPA', 'UoM DEPA', 'REPM', 'UoM REPM',
                'OVHD', 'UoM OVHD'
            ],
            selector: '.recipe-checkbox',
            numericColumns: [13, 15, 18, 21, 23, 25, 27],
            columnWidths: { 0: 30, 3: 20, 4: 45, 5: 45, 9: 15, 11: 45 }
        },
        'production_version': {
            headers: [
                'MATERIAL FG/SFG', 'WERKS/PLANT', 'VERID/PRODUCTION VERSION', 'TEXT1/DESCRIPTION',
                'ADATU/VALID FROM', 'BDATU/VALID TO', 'PLNNR/KEY FOR TASK LIST GROUP',
                'PLNAL/GROUP COUNTER', 'STLAN/BOM USAGE', 'STLAL/ALTERNATIVE BOM',
                'ELPRO/PROPOSED ISSUE SLOC', 'ALORT/RECEIVING SLOC', 'Resource', 'Column 3'
            ],
            selector: '.pv-checkbox',
            hiddenColumns: [12, 13] // Hide columns M (Resource) and N (Column 3)
        }
    };
    
    return configs[tableType] || null;
}

/**
 * Extract data from HTML table
 */
function extractTableData(tableId, config, filterHeaderIds = null) {
    const headers = config.headers;
    const rows = [];
    let exportedRowCount = 0;
    
    // Map table IDs to DataTables instances
    const tableMap = {
        'table_upload_bom': uploadBomTable,
        'table_recipe': recipeTable,
        'table_pv': pvTable
    };
    
    const table = tableMap[tableId];
    
    if (!table) {
        console.error('DataTables instance not found for:', tableId);
        return { headers, rows, exportedRowCount };
    }
    
    // Use DataTables API to iterate ALL rows (including hidden pages)
    table.rows().every(function() {
        const $row = $(this.node());
        const checkbox = $row.find(config.selector);
        
        // Only export checked and enabled rows
        if (checkbox.is(':checked') && !checkbox.is(':disabled')) {
            // Apply headerId filter if provided
            if (filterHeaderIds) {
                const headerId = String($row.data('header-id') || '');
                let filterSet;
                
                // Handle both Set and Array
                if (filterHeaderIds instanceof Set) {
                    filterSet = filterHeaderIds;
                } else if (Array.isArray(filterHeaderIds)) {
                    filterSet = new Set(filterHeaderIds.map(String));
                }
                
                if (filterSet && !filterSet.has(headerId)) {
                    return; // Skip this row
                }
            }

            const row = [];
            let adjustedIndex = 0;
            
            $row.find('td').each(function(index) {
                // Skip checkbox column (index 0) and any columns with export-skip class
                if (index > 0 && !$(this).hasClass('export-skip')) {
                    let cellText = $(this).text().trim();
                    
                    // Format cell value based on column type - use adjustedIndex (not original index)
                    cellText = formatCellValue(cellText, adjustedIndex, config);
                    
                    row.push(cellText);
                    adjustedIndex++;
                }
            });
            
            rows.push(row);
            exportedRowCount++;
        }
    });
    
    return { headers, rows, exportedRowCount };
}

/**
 * Format cell value based on column configuration
 */
function formatCellValue(value, columnIndex, config) {
    // Handle special columns for Upload BOM
    if (config.specialColumns && config.specialColumns[columnIndex]) {
        const specialType = config.specialColumns[columnIndex];
        
        if (specialType === 'valid_from') {
            return value.replace(/'/g, ''); // Remove quotes
        }
        
        if (specialType === 'component_qty') {
            return formatNumericValue(value);
        }
    }
    
    // Handle numeric columns for Recipe
    if (config.numericColumns && config.numericColumns.includes(columnIndex)) {
        return formatNumericValue(value);
    }
    
    return value;
}

/**
 * Format numeric value (remove unnecessary decimals)
 */
function formatNumericValue(value) {
    const numValue = parseFloat(value);
    
    if (isNaN(numValue)) {
        return value;
    }
    
    // Check if it's a whole number
    if (numValue % 1 === 0) {
        return numValue.toString(); // Remove decimals
    }
    
    return numValue.toString(); // Keep decimals
}

/**
 * Create Excel workbook with styling using ExcelJS
 * 
 * @param {array} groupBorders - Array of {startRow, endRow} for group outside borders
 */
async function createWorkbookExcelJS(headers, rows, config, tableType, filename, groupBorders = []) {
    // Create workbook and worksheet
    const workbook = new ExcelJS.Workbook();
    const worksheet = workbook.addWorksheet('Sheet1');
    
    // Add header row
    const headerRow = worksheet.addRow(headers);
    
    // Style header row with Framework MSJ styling
    headerRow.height = 30;
    headerRow.eachCell((cell, colNumber) => {
        // Check if this column will be hidden (colNumber is 1-indexed)
        const columnIndex = colNumber - 1; // Convert to 0-indexed
        const isHiddenColumn = config.hiddenColumns && config.hiddenColumns.includes(columnIndex);
        
        cell.font = {
            bold: true,
            color: { argb: 'FF000000' }, // Black text
            size: 11
        };
        cell.fill = {
            type: 'pattern',
            pattern: 'solid',
            // Yellow background for hidden columns, cyan for normal columns
            fgColor: { argb: isHiddenColumn ? 'FFFFFF00' : 'FF81E6D9' } // Yellow #FFFF00 or Cyan #81E6D9
        };
        cell.alignment = {
            horizontal: 'center',
            vertical: 'middle',
            wrapText: true
        };
        cell.border = {
            top: { style: 'thin', color: { argb: 'FF000000' } },
            left: { style: 'thin', color: { argb: 'FF000000' } },
            bottom: { style: 'thin', color: { argb: 'FF000000' } },
            right: { style: 'thin', color: { argb: 'FF000000' } }
        };
    });
    
    // Add data rows
    rows.forEach(row => {
        worksheet.addRow(row);
    });
    
    // Apply group borders (outside borders per header group)
    if (groupBorders && groupBorders.length > 0) {
        console.log('Applying group borders:', groupBorders);
        
        groupBorders.forEach(group => {
            const startRow = group.startRow;
            const endRow = group.endRow;
            const lastCol = headers.length;
            
            console.log(`Group border: rows ${startRow} to ${endRow}, columns 1 to ${lastCol}`);
            
            // Apply outside border to the group
            for (let row = startRow; row <= endRow; row++) {
                for (let col = 1; col <= lastCol; col++) {
                    const cell = worksheet.getCell(row, col);
                    
                    // Initialize border object if not exists
                    if (!cell.border) {
                        cell.border = {};
                    }
                    
                    // Apply thick outside borders
                    if (row === startRow) {
                        // Top border of group
                        cell.border.top = { style: 'medium', color: { argb: 'FF000000' } };
                    }
                    if (row === endRow) {
                        // Bottom border of group
                        cell.border.bottom = { style: 'medium', color: { argb: 'FF000000' } };
                    }
                    if (col === 1) {
                        // Left border of group
                        cell.border.left = { style: 'medium', color: { argb: 'FF000000' } };
                    }
                    if (col === lastCol) {
                        // Right border of group
                        cell.border.right = { style: 'medium', color: { argb: 'FF000000' } };
                    }
                }
            }
        });
    }
    
    // Auto-size columns
    worksheet.columns.forEach((column, index) => {
        let maxLength = headers[index] ? headers[index].length : 10;
        
        rows.forEach(row => {
            const cellValue = row[index] ? row[index].toString() : '';
            maxLength = Math.max(maxLength, cellValue.length);
        });
        
        // Apply custom width if configured
        if (config.columnWidths && config.columnWidths[index]) {
            column.width = Math.max(maxLength + 2, config.columnWidths[index]);
        } else {
            column.width = Math.min(Math.max(maxLength + 2, 10), 50);
        }
        
        // Hide column if configured
        if (config.hiddenColumns && config.hiddenColumns.includes(index)) {
            column.hidden = true;
        }
    });
    
    // Generate Excel file and download
    const buffer = await workbook.xlsx.writeBuffer();
    const blob = new Blob([buffer], { 
        type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' 
    });
    
    // Create download link
    const url = window.URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.href = url;
    link.download = filename + '.xlsx';
    link.click();
    window.URL.revokeObjectURL(url);
}

// Note: applyColumnWidths() and applyHeaderStyling() functions are no longer needed
// ExcelJS handles styling directly in createWorkbookExcelJS()

/**
 * Show warning when no data selected
 */
function showNoDataWarning(tableType) {
    const tableLabel = tableType.replace(/_/g, ' ').toUpperCase();
    
    Swal.fire({
        icon: 'warning',
        title: 'Tidak Ada Data Terpilih',
        text: `Tidak ada data yang dicentang untuk diekspor dari tabel ${tableLabel}.`,
        confirmButtonColor: '#ffc107'
    });
}

/**
 * Show success message after export
 */
function showSuccessMessage(filename, rowCount) {
    Swal.fire({
        icon: 'success',
        title: 'Export Berhasil!',
        text: `${filename}.xlsx telah berhasil diunduh (${rowCount} data)`,
        timer: 2000,
        showConfirmButton: false
    });
}

/**
 * Show error message
 */
function showErrorMessage(errorText) {
    Swal.fire({
        icon: 'error',
        title: 'Export Gagal',
        text: errorText || 'Terjadi kesalahan saat mengekspor file'
    });
}
</script>